#include "py/mpconfig.h"
#include "py/objint.h"
#include "py/objstr.h"
#include "py/emitglue.h"

#if MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE != 0
#error "incompatible MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE"
#endif

#if MICROPY_LONGINT_IMPL != 2
#error "incompatible MICROPY_LONGINT_IMPL"
#endif

#if MPZ_DIG_SIZE != 16
#error "incompatible MPZ_DIG_SIZE"
#endif

#if MICROPY_PY_BUILTINS_FLOAT
typedef struct _mp_obj_float_t {
    mp_obj_base_t base;
    mp_float_t value;
} mp_obj_float_t;
#endif

#if MICROPY_PY_BUILTINS_COMPLEX
typedef struct _mp_obj_complex_t {
    mp_obj_base_t base;
    mp_float_t real;
    mp_float_t imag;
} mp_obj_complex_t;
#endif

enum {
    MP_QSTR_lcd160cr_dot_py = MP_QSTRnumber_of,
    MP_QSTR_PORTRAIT,
    MP_QSTR_LANDSCAPE,
    MP_QSTR_PORTRAIT_UPSIDEDOWN,
    MP_QSTR_LANDSCAPE_UPSIDEDOWN,
    MP_QSTR_STARTUP_DECO_NONE,
    MP_QSTR_STARTUP_DECO_MLOGO,
    MP_QSTR_STARTUP_DECO_INFO,
    MP_QSTR__uart_baud_table,
    MP_QSTR_LCD160CR,
    MP_QSTR_pwr,
    MP_QSTR_i2c,
    MP_QSTR_spi,
    MP_QSTR_i2c_addr,
    MP_QSTR__send,
    MP_QSTR__fcmd2,
    MP_QSTR__fcmd2b,
    MP_QSTR__waitfor,
    MP_QSTR_oflush,
    MP_QSTR_iflush,
    MP_QSTR_rgb,
    MP_QSTR_clip_line,
    MP_QSTR_set_power,
    MP_QSTR_set_orient,
    MP_QSTR_set_brightness,
    MP_QSTR_set_i2c_addr,
    MP_QSTR_set_uart_baudrate,
    MP_QSTR_set_startup_deco,
    MP_QSTR_save_to_flash,
    MP_QSTR_set_pixel,
    MP_QSTR_get_pixel,
    MP_QSTR_get_line,
    MP_QSTR_screen_dump,
    MP_QSTR_screen_load,
    MP_QSTR_set_pos,
    MP_QSTR_set_text_color,
    MP_QSTR_set_pen,
    MP_QSTR_erase,
    MP_QSTR_dot,
    MP_QSTR_rect_outline,
    MP_QSTR_rect_interior,
    MP_QSTR_line,
    MP_QSTR_dot_no_clip,
    MP_QSTR_rect_no_clip,
    MP_QSTR_rect_outline_no_clip,
    MP_QSTR_rect_interior_no_clip,
    MP_QSTR_line_no_clip,
    MP_QSTR_poly_dot,
    MP_QSTR_poly_line,
    MP_QSTR_touch_config,
    MP_QSTR_is_touched,
    MP_QSTR_get_touch,
    MP_QSTR_set_spi_win,
    MP_QSTR_fast_spi,
    MP_QSTR_show_framebuf,
    MP_QSTR_set_scroll,
    MP_QSTR_set_scroll_win,
    MP_QSTR_set_scroll_win_param,
    MP_QSTR_set_scroll_buf,
    MP_QSTR_jpeg_start,
    MP_QSTR_jpeg_data,
    MP_QSTR_jpeg,
    MP_QSTR_feed_wdt,
    MP_QSTR_X,
    MP_QSTR_Y,
    MP_QSTR_XY,
    MP_QSTR_YX,
    MP_QSTR_4,
    MP_QSTR_C,
    MP_QSTR_A7,
    MP_QSTR_buf16,
    MP_QSTR_buf19,
    MP_QSTR_buf,
    MP_QSTR_buf1,
    MP_QSTR_array4,
    MP_QSTR__lt_BBBBBB,
    MP_QSTR_w,
    MP_QSTR_h,
    MP_QSTR_self,
    MP_QSTR_connect,
    MP_QSTR_cmd,
    MP_QSTR_fmt,
    MP_QSTR_a0,
    MP_QSTR_a1,
    MP_QSTR_a2,
    MP_QSTR_a3,
    MP_QSTR_a4,
    MP_QSTR_n,
    MP_QSTR_g,
    MP_QSTR_c,
    MP_QSTR__lt_BBB,
    MP_QSTR_orient,
    MP_QSTR__lt_BBW,
    MP_QSTR__lt_BBBBH,
    MP_QSTR_x,
    MP_QSTR_y,
    MP_QSTR__lt_BBBB,
    MP_QSTR__lt_BBBBB,
    MP_QSTR__lt_BBHBBB,
    MP_QSTR__lt_BBHH,
    MP_QSTR_fg,
    MP_QSTR_bg,
    MP_QSTR_scale,
    MP_QSTR_bold,
    MP_QSTR_trans,
    MP_QSTR_scroll,
    MP_QSTR_s,
    MP_QSTR_fill,
    MP_QSTR_x1,
    MP_QSTR_y1,
    MP_QSTR_x2,
    MP_QSTR_y2,
    MP_QSTR_calib,
    MP_QSTR_save,
    MP_QSTR_irq,
    MP_QSTR_win,
    MP_QSTR_vec,
    MP_QSTR_pat,
    MP_QSTR_color,
    MP_QSTR_param,
    MP_QSTR__lt_BBH,
    MP_QSTR_l,
    MP_QSTR_lcd160cr_test_dot_py,
    MP_QSTR_framebuf,
    MP_QSTR_lcd160cr,
    MP_QSTR_get_lcd,
    MP_QSTR_show_adc,
    MP_QSTR_test_features,
    MP_QSTR_test_mandel,
    MP_QSTR_test_all,
    MP_QSTR_lcd,
    MP_QSTR_read_core_temp,
    MP_QSTR_read_core_vbat,
    MP_QSTR_read_vref,
    MP_QSTR__percent_4s_colon__space_,
    MP_QSTR_TEMP,
    MP_QSTR_VBAT,
    MP_QSTR_VREF,
    MP_QSTR__percent_6_dot_3fV,
    MP_QSTR__percent_5_dot_1f_Acirc__deg_C,
    MP_QSTR_adc,
    MP_QSTR_ADCAll,
    MP_QSTR_FrameBuffer,
    MP_QSTR_RGB565,
    MP_QSTR_fill_rect,
    MP_QSTR_vline,
    MP_QSTR_hline,
    MP_QSTR_blit,
    MP_QSTR_text,
    MP_QSTR_datetime,
    MP_QSTR__percent__dot_2f_space_fps,
    MP_QSTR_in_set,
};

extern const qstr_pool_t mp_qstr_const_pool;
const qstr_pool_t mp_qstr_frozen_const_pool = {
    (qstr_pool_t*)&mp_qstr_const_pool, // previous pool
    MP_QSTRnumber_of, // previous pool size
    152, // allocated entries
    152, // used entries
    {
        (const byte*)"\xcf\xa5\x0b" "lcd160cr.py",
        (const byte*)"\xf2\xcd\x08" "PORTRAIT",
        (const byte*)"\xa6\x7b\x09" "LANDSCAPE",
        (const byte*)"\x01\xb5\x13" "PORTRAIT_UPSIDEDOWN",
        (const byte*)"\xd5\x40\x14" "LANDSCAPE_UPSIDEDOWN",
        (const byte*)"\xa7\xaf\x11" "STARTUP_DECO_NONE",
        (const byte*)"\x2b\x04\x12" "STARTUP_DECO_MLOGO",
        (const byte*)"\xc3\x10\x11" "STARTUP_DECO_INFO",
        (const byte*)"\x44\xc8\x10" "_uart_baud_table",
        (const byte*)"\xc8\x0e\x08" "LCD160CR",
        (const byte*)"\x30\x70\x03" "pwr",
        (const byte*)"\x5d\x5f\x03" "i2c",
        (const byte*)"\xcf\x8d\x03" "spi",
        (const byte*)"\x11\x1f\x08" "i2c_addr",
        (const byte*)"\x46\xdc\x05" "_send",
        (const byte*)"\x24\x42\x06" "_fcmd2",
        (const byte*)"\xc6\x86\x07" "_fcmd2b",
        (const byte*)"\xca\x81\x08" "_waitfor",
        (const byte*)"\xce\x08\x06" "oflush",
        (const byte*)"\x08\xd7\x06" "iflush",
        (const byte*)"\xb2\x8a\x03" "rgb",
        (const byte*)"\x22\xd7\x09" "clip_line",
        (const byte*)"\xa7\xfd\x09" "set_power",
        (const byte*)"\xd3\x6a\x0a" "set_orient",
        (const byte*)"\x91\xbe\x0e" "set_brightness",
        (const byte*)"\x8c\xe7\x0c" "set_i2c_addr",
        (const byte*)"\xc5\xd9\x11" "set_uart_baudrate",
        (const byte*)"\x8f\xbe\x10" "set_startup_deco",
        (const byte*)"\x0f\x3f\x0d" "save_to_flash",
        (const byte*)"\xb0\xda\x09" "set_pixel",
        (const byte*)"\xa4\x17\x09" "get_pixel",
        (const byte*)"\x82\x28\x08" "get_line",
        (const byte*)"\x9a\x5d\x0b" "screen_dump",
        (const byte*)"\x10\xea\x0b" "screen_load",
        (const byte*)"\x54\x6d\x07" "set_pos",
        (const byte*)"\x07\xa7\x0e" "set_text_color",
        (const byte*)"\x83\x6d\x07" "set_pen",
        (const byte*)"\xe5\x45\x05" "erase",
        (const byte*)"\x3a\x1f\x03" "dot",
        (const byte*)"\xda\x1c\x0c" "rect_outline",
        (const byte*)"\xca\x14\x0d" "rect_interior",
        (const byte*)"\xcb\x1c\x04" "line",
        (const byte*)"\xed\x75\x0b" "dot_no_clip",
        (const byte*)"\x72\x73\x0c" "rect_no_clip",
        (const byte*)"\x8d\x0a\x14" "rect_outline_no_clip",
        (const byte*)"\x9d\x7e\x15" "rect_interior_no_clip",
        (const byte*)"\x5c\x4e\x0c" "line_no_clip",
        (const byte*)"\x6f\x13\x08" "poly_dot",
        (const byte*)"\xfe\x9a\x09" "poly_line",
        (const byte*)"\x15\x99\x0c" "touch_config",
        (const byte*)"\x04\x72\x0a" "is_touched",
        (const byte*)"\x69\xf2\x09" "get_touch",
        (const byte*)"\x9d\x18\x0b" "set_spi_win",
        (const byte*)"\xf0\x3a\x08" "fast_spi",
        (const byte*)"\x75\x65\x0d" "show_framebuf",
        (const byte*)"\x35\xb2\x0a" "set_scroll",
        (const byte*)"\xda\x67\x0e" "set_scroll_win",
        (const byte*)"\x8a\xbd\x14" "set_scroll_win_param",
        (const byte*)"\x1b\x1a\x0e" "set_scroll_buf",
        (const byte*)"\x22\xea\x0a" "jpeg_start",
        (const byte*)"\x52\x10\x09" "jpeg_data",
        (const byte*)"\x7d\xe7\x04" "jpeg",
        (const byte*)"\x3f\x67\x08" "feed_wdt",
        (const byte*)"\xfd\xb5\x01" "X",
        (const byte*)"\xfc\xb5\x01" "Y",
        (const byte*)"\xc4\x75\x02" "XY",
        (const byte*)"\x24\x75\x02" "YX",
        (const byte*)"\x91\xb5\x01" "4",
        (const byte*)"\xe6\xb5\x01" "C",
        (const byte*)"\x53\x72\x02" "A7",
        (const byte*)"\x53\x70\x05" "buf16",
        (const byte*)"\x5c\x70\x05" "buf19",
        (const byte*)"\x74\x49\x03" "buf",
        (const byte*)"\xc5\x77\x04" "buf1",
        (const byte*)"\xc8\xc1\x06" "array4",
        (const byte*)"\x19\x0d\x07" "<BBBBBB",
        (const byte*)"\xd2\xb5\x01" "w",
        (const byte*)"\xcd\xb5\x01" "h",
        (const byte*)"\x79\x77\x04" "self",
        (const byte*)"\xdb\x3d\x07" "connect",
        (const byte*)"\x2f\x4c\x03" "cmd",
        (const byte*)"\x7a\x38\x03" "fmt",
        (const byte*)"\x74\x6e\x02" "a0",
        (const byte*)"\x75\x6e\x02" "a1",
        (const byte*)"\x76\x6e\x02" "a2",
        (const byte*)"\x77\x6e\x02" "a3",
        (const byte*)"\x70\x6e\x02" "a4",
        (const byte*)"\xcb\xb5\x01" "n",
        (const byte*)"\xc2\xb5\x01" "g",
        (const byte*)"\xc6\xb5\x01" "c",
        (const byte*)"\x7b\x8b\x04" "<BBB",
        (const byte*)"\x8e\x81\x06" "orient",
        (const byte*)"\x6e\x8b\x04" "<BBW",
        (const byte*)"\xf1\x4d\x06" "<BBBBH",
        (const byte*)"\xdd\xb5\x01" "x",
        (const byte*)"\xdc\xb5\x01" "y",
        (const byte*)"\x99\xfa\x05" "<BBBB",
        (const byte*)"\xfb\x4d\x06" "<BBBBB",
        (const byte*)"\xd3\xc2\x07" "<BBHBBB",
        (const byte*)"\xd9\xf9\x05" "<BBHH",
        (const byte*)"\x44\x6e\x02" "fg",
        (const byte*)"\xc0\x6e\x02" "bg",
        (const byte*)"\x7d\x51\x05" "scale",
        (const byte*)"\x40\x3c\x04" "bold",
        (const byte*)"\x5f\x45\x05" "trans",
        (const byte*)"\x28\x5a\x06" "scroll",
        (const byte*)"\xd6\xb5\x01" "s",
        (const byte*)"\xca\x34\x04" "fill",
        (const byte*)"\x4c\x71\x02" "x1",
        (const byte*)"\x6d\x71\x02" "y1",
        (const byte*)"\x4f\x71\x02" "x2",
        (const byte*)"\x6e\x71\x02" "y2",
        (const byte*)"\xc0\xed\x05" "calib",
        (const byte*)"\xa4\x83\x04" "save",
        (const byte*)"\x8f\x56\x03" "irq",
        (const byte*)"\xb5\x7f\x03" "win",
        (const byte*)"\x75\x7b\x03" "vec",
        (const byte*)"\xe0\x72\x03" "pat",
        (const byte*)"\xd8\x06\x05" "color",
        (const byte*)"\xca\xc8\x05" "param",
        (const byte*)"\x71\x8b\x04" "<BBH",
        (const byte*)"\xc9\xb5\x01" "l",
        (const byte*)"\x46\x96\x10" "lcd160cr_test.py",
        (const byte*)"\x69\x82\x08" "framebuf",
        (const byte*)"\xe8\xf0\x08" "lcd160cr",
        (const byte*)"\xc7\x27\x07" "get_lcd",
        (const byte*)"\xdf\x50\x08" "show_adc",
        (const byte*)"\x2b\x6e\x0d" "test_features",
        (const byte*)"\xc3\x88\x0b" "test_mandel",
        (const byte*)"\xad\xc8\x08" "test_all",
        (const byte*)"\xae\x3f\x03" "lcd",
        (const byte*)"\xe0\xc2\x0e" "read_core_temp",
        (const byte*)"\xed\xb7\x0e" "read_core_vbat",
        (const byte*)"\x6f\x00\x09" "read_vref",
        (const byte*)"\x9d\x48\x05" "%4s: ",
        (const byte*)"\xe9\xd1\x04" "TEMP",
        (const byte*)"\x24\xc4\x04" "VBAT",
        (const byte*)"\xa2\x80\x04" "VREF",
        (const byte*)"\x1b\x2a\x06" "%6.3fV",
        (const byte*)"\x7d\x03\x08" "\x25\x35\x2e\x31\x66\xc2\xb0\x43",
        (const byte*)"\x43\x32\x03" "adc",
        (const byte*)"\x02\x28\x06" "ADCAll",
        (const byte*)"\xd8\xbe\x0b" "FrameBuffer",
        (const byte*)"\x64\xcc\x06" "RGB565",
        (const byte*)"\x35\xed\x09" "fill_rect",
        (const byte*)"\x1d\xf6\x05" "vline",
        (const byte*)"\x83\x3c\x05" "hline",
        (const byte*)"\xf6\x50\x04" "blit",
        (const byte*)"\x98\xaf\x04" "text",
        (const byte*)"\xe4\x04\x08" "datetime",
        (const byte*)"\x7f\x5a\x08" "%.2f fps",
        (const byte*)"\x1f\x11\x06" "in_set",
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR___init__
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR___init__[394] = {
    0x12, 0x00, 0x08, 0x02, 0x04, 0x01, 0x2a,
    MP_QSTR___init__ & 0xff, MP_QSTR___init__ >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x21, 0x33, 0x24, 0x24, 0x29, 0x28, 0x22, 0x22, 0x47, 0x32, 0x49, 0x26, 0x33, 0x26, 0x32, 0x26, 0x5b, 0x29, 0x25, 0x67, 0x60, 0x25, 0x25, 0x25, 0x65, 0x2a, 0x2a, 0x29, 0x26, 0x3d, 0x2a, 0x6a, 0x28, 0x37, 0x00, 0x00, 0xff,
    0xb1, 
    0x16, MP_QSTR_X & 0xff, MP_QSTR_X >> 8,
    0x16, MP_QSTR_Y & 0xff, MP_QSTR_Y >> 8,
    0x16, MP_QSTR_XY & 0xff, MP_QSTR_XY >> 8,
    0x16, MP_QSTR_YX & 0xff, MP_QSTR_YX >> 8,
    0x50, 0x04, 
    0xdd, 
    0x37, 0x11, 0x80, 
    0xb1, 
    0x7f, 
    0x21, 
    0xc6, 
    0xb1, 
    0x80, 
    0x21, 
    0xc7, 
    0xb7, 
    0x16, MP_QSTR_4 & 0xff, MP_QSTR_4 >> 8,
    0xf1, 
    0xc8, 
    0x35, 0x2e, 0x80, 
    0xb1, 
    0x16, MP_QSTR_C & 0xff, MP_QSTR_C >> 8,
    0xd9, 
    0x37, 0x0b, 0x80, 
    0x82, 
    0xc6, 
    0x82, 
    0xc7, 
    0x16, MP_QSTR_A7 & 0xff, MP_QSTR_A7 >> 8,
    0xc8, 
    0x35, 0x1b, 0x80, 
    0xb2, 
    0x11, 
    0xde, 
    0x36, 0x0c, 0x80, 
    0xb3, 
    0x11, 
    0xde, 
    0x36, 0x06, 0x80, 
    0xb4, 
    0x11, 
    0xde, 
    0x37, 0x09, 0x80, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x06, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0xb2, 
    0x11, 
    0xde, 
    0x37, 0x13, 0x80, 
    0x1c, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x1e, MP_QSTR_Pin & 0xff, MP_QSTR_Pin >> 8,
    0xb8, 
    0x1c, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x1d, MP_QSTR_Pin & 0xff, MP_QSTR_Pin >> 8,
    0x1d, MP_QSTR_OUT & 0xff, MP_QSTR_OUT >> 8,
    0x66, 0x02, 
    0xc2, 
    0xb3, 
    0x11, 
    0xde, 
    0x37, 0x12, 0x80, 
    0x1c, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x1e, MP_QSTR_I2C & 0xff, MP_QSTR_I2C >> 8,
    0xb6, 
    0x16, MP_QSTR_freq & 0xff, MP_QSTR_freq >> 8,
    0x14, 0xbd, 0x84, 0x40, 
    0x66, 0x82, 0x01, 
    0xc3, 
    0xb4, 
    0x11, 
    0xde, 
    0x37, 0x1b, 0x80, 
    0x1c, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x1e, MP_QSTR_SPI & 0xff, MP_QSTR_SPI >> 8,
    0xb7, 
    0x16, MP_QSTR_baudrate & 0xff, MP_QSTR_baudrate >> 8,
    0x14, 0x86, 0xb7, 0xfc, 0x60, 
    0x16, MP_QSTR_polarity & 0xff, MP_QSTR_polarity >> 8,
    0x80, 
    0x16, MP_QSTR_phase & 0xff, MP_QSTR_phase >> 8,
    0x80, 
    0x66, 0x86, 0x01, 
    0xc4, 
    0xb2, 
    0x1e, MP_QSTR_value & 0xff, MP_QSTR_value >> 8,
    0x66, 0x00, 
    0x36, 0x0c, 0x80, 
    0xb2, 
    0x81, 
    0x64, 0x01, 
    0x32, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x8a, 
    0x64, 0x01, 
    0x32, 
    0xb2, 
    0xb0, 
    0x26, MP_QSTR_pwr & 0xff, MP_QSTR_pwr >> 8,
    0xb3, 
    0xb0, 
    0x26, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0xb4, 
    0xb0, 
    0x26, MP_QSTR_spi & 0xff, MP_QSTR_spi >> 8,
    0xb5, 
    0xb0, 
    0x26, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0x90, 
    0x64, 0x01, 
    0xb0, 
    0x26, MP_QSTR_buf16 & 0xff, MP_QSTR_buf16 >> 8,
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0x93, 
    0x64, 0x01, 
    0xb0, 
    0x26, MP_QSTR_buf19 & 0xff, MP_QSTR_buf19 >> 8,
    0x11, 
    0x51, 0x01, 
    0x8a, 
    0xf3, 
    0xb0, 
    0x26, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x81, 
    0x35, 0x18, 0x80, 
    0x30, 
    0xc6, 
    0x1c, MP_QSTR_memoryview & 0xff, MP_QSTR_memoryview >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf16 & 0xff, MP_QSTR_buf16 >> 8,
    0x64, 0x01, 
    0x80, 
    0xb6, 
    0x58, 0x02, 
    0x21, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0xb6, 
    0x27, 
    0x81, 
    0xe5, 
    0x30, 
    0x8a, 
    0xd7, 
    0x36, 0xe2, 0x7f, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x81, 
    0x21, 
    0xb0, 
    0x26, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x80, 
    0x80, 
    0x80, 
    0x80, 
    0x51, 0x04, 
    0xb0, 
    0x26, MP_QSTR_array4 & 0xff, MP_QSTR_array4 >> 8,
    0xb0, 
    0x1e, MP_QSTR_set_orient & 0xff, MP_QSTR_set_orient >> 8,
    0x80, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x76, 
    0x80, 
    0x80, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x66, 0x06, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x79, 
    0x80, 
    0x80, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR___init___0 = {{&mp_type_str}, 26676, 61, (const byte*)"\x6d\x75\x73\x74\x20\x73\x70\x65\x63\x69\x66\x79\x20\x76\x61\x6c\x69\x64\x20\x22\x63\x6f\x6e\x6e\x65\x63\x74\x22\x20\x6f\x72\x20\x61\x6c\x6c\x20\x6f\x66\x20\x22\x70\x77\x72\x22\x2c\x20\x22\x69\x32\x63\x22\x20\x61\x6e\x64\x20\x22\x73\x70\x69\x22"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR___init__[7] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_connect),
    MP_ROM_QSTR(MP_QSTR_pwr),
    MP_ROM_QSTR(MP_QSTR_i2c),
    MP_ROM_QSTR(MP_QSTR_spi),
    MP_ROM_QSTR(MP_QSTR_i2c_addr),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR___init___0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR___init__ = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x08,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR___init__,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR___init__,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 394,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR__send
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR__send[109] = {
    0x0b, 0x00, 0x00, 0x02, 0x00, 0x00, 0x12,
    MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x50, 0x2f, 0x2b, 0x22, 0x27, 0x27, 0x20, 0x36, 0x26, 0x22, 0x00, 0x00, 0xff,
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_writeto & 0xff, MP_QSTR_writeto >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb1, 
    0x66, 0x02, 
    0xc2, 
    0xb2, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0xd9, 
    0x37, 0x02, 0x80, 
    0x11, 
    0x5b, 
    0x1c, MP_QSTR_memoryview & 0xff, MP_QSTR_memoryview >> 8,
    0xb1, 
    0x64, 0x01, 
    0xc1, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0xc3, 
    0xb2, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_writeto & 0xff, MP_QSTR_writeto >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb1, 
    0xb2, 
    0x11, 
    0x58, 0x02, 
    0x21, 
    0x66, 0x02, 
    0xe5, 
    0xc2, 
    0xb2, 
    0xb3, 
    0xd9, 
    0x37, 0x02, 0x80, 
    0x11, 
    0x5b, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x8a, 
    0x64, 0x01, 
    0x32, 
    0x35, 0xd8, 0x7f, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR__send[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_cmd),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR__send = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR__send,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR__send,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 109,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR__fcmd2
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2[53] = {
    0x0e, 0x00, 0x00, 0x05, 0x00, 0x02, 0x0b,
    MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x5c, 0x2c, 0x2d, 0x00, 0x00, 0xff,
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x1c, MP_QSTR_calcsize & 0xff, MP_QSTR_calcsize >> 8,
    0xb1, 
    0x64, 0x01, 
    0x21, 
    0xc5, 
    0x1c, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0xb1, 
    0xb5, 
    0x80, 
    0x82, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x64, 0x07, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb5, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_fmt),
    MP_ROM_QSTR(MP_QSTR_a0),
    MP_ROM_QSTR(MP_QSTR_a1),
    MP_ROM_QSTR(MP_QSTR_a2),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR__fcmd2 = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 53,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR__fcmd2b
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2b[55] = {
    0x12, 0x00, 0x00, 0x07, 0x00, 0x01, 0x0b,
    MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x61, 0x2c, 0x2f, 0x00, 0x00, 0xff,
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x1c, MP_QSTR_calcsize & 0xff, MP_QSTR_calcsize >> 8,
    0xb1, 
    0x64, 0x01, 
    0x21, 
    0xc7, 
    0x1c, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0xb1, 
    0xb7, 
    0x80, 
    0x82, 
    0xb2, 
    0xb3, 
    0xb4, 
    0xb5, 
    0xb6, 
    0x64, 0x09, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb7, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2b[7] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_fmt),
    MP_ROM_QSTR(MP_QSTR_a0),
    MP_ROM_QSTR(MP_QSTR_a1),
    MP_ROM_QSTR(MP_QSTR_a2),
    MP_ROM_QSTR(MP_QSTR_a3),
    MP_ROM_QSTR(MP_QSTR_a4),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR__fcmd2b = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 7,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2b,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR__fcmd2b,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 55,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR__waitfor
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR__waitfor[107] = {
    0x08, 0x00, 0x00, 0x03, 0x00, 0x00, 0x11,
    MP_QSTR__waitfor & 0xff, MP_QSTR__waitfor >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x66, 0x24, 0x23, 0x32, 0x2b, 0x2f, 0x22, 0x24, 0x2b, 0x00, 0x00, 0xff,
    0x14, 0xa7, 0x08, 
    0xc3, 
    0x35, 0x39, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x80, 
    0x21, 
    0xb1, 
    0xdb, 
    0x37, 0x11, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb2, 
    0x66, 0x02, 
    0x32, 
    0x11, 
    0x5b, 
    0xb3, 
    0x81, 
    0xe6, 
    0xc3, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x81, 
    0x64, 0x01, 
    0x32, 
    0xb3, 
    0x36, 0xc3, 0x7f, 
    0x1c, MP_QSTR_OSError & 0xff, MP_QSTR_OSError >> 8,
    0x1c, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x1d, MP_QSTR_ETIMEDOUT & 0xff, MP_QSTR_ETIMEDOUT >> 8,
    0x64, 0x01, 
    0x5c, 0x01, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR__waitfor[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_n),
    MP_ROM_QSTR(MP_QSTR_buf),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR__waitfor = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR__waitfor,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR__waitfor,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 107,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_oflush
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_oflush[98] = {
    0x08, 0x00, 0x00, 0x02, 0x00, 0x01, 0x11,
    MP_QSTR_oflush & 0xff, MP_QSTR_oflush >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x71, 0x24, 0x23, 0x34, 0x27, 0x26, 0x22, 0x24, 0x2d, 0x00, 0x00, 0xff,
    0x14, 0xa7, 0x08, 
    0xc2, 
    0x35, 0x30, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0x81, 
    0xf1, 
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x80, 
    0x21, 
    0xc3, 
    0xb3, 
    0xb1, 
    0xdb, 
    0x37, 0x02, 0x80, 
    0x11, 
    0x5b, 
    0xb2, 
    0x81, 
    0xe6, 
    0xc2, 
    0x1c, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x1e, MP_QSTR_idle & 0xff, MP_QSTR_idle >> 8,
    0x66, 0x00, 
    0x32, 
    0xb2, 
    0x36, 0xcc, 0x7f, 
    0x1c, MP_QSTR_OSError & 0xff, MP_QSTR_OSError >> 8,
    0x1c, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x1d, MP_QSTR_ETIMEDOUT & 0xff, MP_QSTR_ETIMEDOUT >> 8,
    0x64, 0x01, 
    0x5c, 0x01, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_oflush[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_n),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_oflush = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_oflush,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_oflush,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 98,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_iflush
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_iflush[91] = {
    0x06, 0x00, 0x00, 0x01, 0x00, 0x00, 0x10,
    MP_QSTR_iflush & 0xff, MP_QSTR_iflush >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x7c, 0x24, 0x23, 0x32, 0x2b, 0x22, 0x24, 0x2b, 0x00, 0x00, 0xff,
    0x14, 0xa7, 0x08, 
    0xc1, 
    0x35, 0x2a, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf16 & 0xff, MP_QSTR_buf16 >> 8,
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf16 & 0xff, MP_QSTR_buf16 >> 8,
    0x80, 
    0x21, 
    0x80, 
    0xd9, 
    0x37, 0x02, 0x80, 
    0x11, 
    0x5b, 
    0xb1, 
    0x81, 
    0xe6, 
    0xc1, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x81, 
    0x64, 0x01, 
    0x32, 
    0xb1, 
    0x36, 0xd2, 0x7f, 
    0x1c, MP_QSTR_OSError & 0xff, MP_QSTR_OSError >> 8,
    0x1c, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x1d, MP_QSTR_ETIMEDOUT & 0xff, MP_QSTR_ETIMEDOUT >> 8,
    0x64, 0x01, 
    0x5c, 0x01, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_iflush[1] = {
    MP_ROM_QSTR(MP_QSTR_self),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_iflush = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_iflush,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_iflush,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 91,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rgb
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rgb[36] = {
    0x06, 0x00, 0x00, 0x03, 0x00, 0x00, 0x09,
    MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x89, 0x00, 0x00, 0xff,
    0xb2, 
    0x14, 0x81, 0x78, 
    0xee, 
    0x88, 
    0xef, 
    0xb1, 
    0x14, 0x81, 0x7c, 
    0xee, 
    0x83, 
    0xef, 
    0xec, 
    0xb0, 
    0x83, 
    0xf0, 
    0xec, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rgb[3] = {
    MP_ROM_QSTR(MP_QSTR_r),
    MP_ROM_QSTR(MP_QSTR_g),
    MP_ROM_QSTR(MP_QSTR_b),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rgb = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rgb,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rgb,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 36,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_clip_line
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_clip_line[606] = {
    0x0c, 0x00, 0x00, 0x03, 0x00, 0x00, 0x40,
    MP_QSTR_clip_line & 0xff, MP_QSTR_clip_line >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0x8d, 0x20, 0x24, 0x28, 0x27, 0x28, 0x27, 0x28, 0x27, 0x28, 0x27, 0x28, 0x27, 0x28, 0x27, 0x28, 0x27, 0x28, 0x27, 0x26, 0x22, 0x26, 0x24, 0x26, 0x2a, 0x2d, 0x2d, 0x3b, 0x27, 0x26, 0x2a, 0x2d, 0x2d, 0x3e, 0x29, 0x26, 0x2a, 0x28, 0x26, 0x28, 0x49, 0x2a, 0x2d, 0x2d, 0x3e, 0x49, 0x2a, 0x28, 0x24, 0x28, 0x47, 0x2a, 0x2d, 0x2d, 0x3b, 0x47, 0x00, 0x00, 0xff,
    0x80, 
    0x30, 
    0xc3, 
    0xc4, 
    0xb0, 
    0x81, 
    0x21, 
    0x80, 
    0xd7, 
    0x37, 0x07, 0x80, 
    0xb3, 
    0x88, 
    0xe0, 
    0xc3, 
    0x35, 0x0f, 0x80, 
    0xb0, 
    0x81, 
    0x21, 
    0xb2, 
    0xd8, 
    0x37, 0x07, 0x80, 
    0xb3, 
    0x84, 
    0xe0, 
    0xc3, 
    0x35, 0x00, 0x80, 
    0xb0, 
    0x80, 
    0x21, 
    0x80, 
    0xd7, 
    0x37, 0x07, 0x80, 
    0xb3, 
    0x81, 
    0xe0, 
    0xc3, 
    0x35, 0x0f, 0x80, 
    0xb0, 
    0x80, 
    0x21, 
    0xb1, 
    0xd8, 
    0x37, 0x07, 0x80, 
    0xb3, 
    0x82, 
    0xe0, 
    0xc3, 
    0x35, 0x00, 0x80, 
    0xb0, 
    0x83, 
    0x21, 
    0x80, 
    0xd7, 
    0x37, 0x07, 0x80, 
    0xb4, 
    0x88, 
    0xe0, 
    0xc4, 
    0x35, 0x0f, 0x80, 
    0xb0, 
    0x83, 
    0x21, 
    0xb2, 
    0xd8, 
    0x37, 0x07, 0x80, 
    0xb4, 
    0x84, 
    0xe0, 
    0xc4, 
    0x35, 0x00, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0x80, 
    0xd7, 
    0x37, 0x07, 0x80, 
    0xb4, 
    0x81, 
    0xe0, 
    0xc4, 
    0x35, 0x0f, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb1, 
    0xd8, 
    0x37, 0x07, 0x80, 
    0xb4, 
    0x82, 
    0xe0, 
    0xc4, 
    0x35, 0x00, 0x80, 
    0xb3, 
    0xb4, 
    0xee, 
    0x37, 0x02, 0x80, 
    0x10, 
    0x5b, 
    0xb3, 
    0xb4, 
    0xec, 
    0x37, 0x86, 0x81, 
    0xb3, 
    0xb4, 
    0xe0, 
    0xc3, 
    0xb3, 
    0x81, 
    0xee, 
    0x37, 0x46, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xd7, 
    0x37, 0x1a, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0x33, 
    0xb0, 
    0x80, 
    0x27, 
    0xb0, 
    0x82, 
    0x27, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0x33, 
    0xb0, 
    0x81, 
    0x27, 
    0xb0, 
    0x83, 
    0x27, 
    0xb0, 
    0x81, 
    0x31, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xd1, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xf2, 
    0xf3, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xf2, 
    0xf4, 
    0xe5, 
    0x34, 
    0x27, 
    0x80, 
    0xb0, 
    0x80, 
    0x27, 
    0x35, 0x33, 0x81, 
    0xb3, 
    0x82, 
    0xee, 
    0x37, 0x4b, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xd7, 
    0x37, 0x1a, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0x33, 
    0xb0, 
    0x80, 
    0x27, 
    0xb0, 
    0x82, 
    0x27, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0x33, 
    0xb0, 
    0x81, 
    0x27, 
    0xb0, 
    0x83, 
    0x27, 
    0xb0, 
    0x83, 
    0x31, 
    0x21, 
    0xb1, 
    0x81, 
    0xf2, 
    0xb0, 
    0x82, 
    0x21, 
    0xf2, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xf2, 
    0xf3, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xf2, 
    0xf4, 
    0xe5, 
    0x34, 
    0x27, 
    0xb1, 
    0x81, 
    0xf2, 
    0xb0, 
    0x82, 
    0x27, 
    0x35, 0xe2, 0x80, 
    0xb3, 
    0x84, 
    0xee, 
    0x37, 0x74, 0x80, 
    0xb0, 
    0x80, 
    0x21, 
    0xb0, 
    0x82, 
    0x21, 
    0xd9, 
    0x37, 0x1f, 0x80, 
    0xb0, 
    0x81, 
    0x21, 
    0xb2, 
    0xdb, 
    0x37, 0x06, 0x80, 
    0xb2, 
    0x81, 
    0xf2, 
    0xb0, 
    0x81, 
    0x27, 
    0xb0, 
    0x83, 
    0x21, 
    0xb2, 
    0xdb, 
    0x37, 0x06, 0x80, 
    0xb2, 
    0x81, 
    0xf2, 
    0xb0, 
    0x83, 
    0x27, 
    0x35, 0x48, 0x80, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xd7, 
    0x37, 0x1a, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0x33, 
    0xb0, 
    0x80, 
    0x27, 
    0xb0, 
    0x82, 
    0x27, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0x33, 
    0xb0, 
    0x81, 
    0x27, 
    0xb0, 
    0x83, 
    0x27, 
    0xb0, 
    0x82, 
    0x31, 
    0x21, 
    0xb2, 
    0x81, 
    0xf2, 
    0xb0, 
    0x83, 
    0x21, 
    0xf2, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xf2, 
    0xf3, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xf2, 
    0xf4, 
    0xe5, 
    0x34, 
    0x27, 
    0xb2, 
    0x81, 
    0xf2, 
    0xb0, 
    0x83, 
    0x27, 
    0x35, 0x68, 0x80, 
    0xb0, 
    0x80, 
    0x21, 
    0xb0, 
    0x82, 
    0x21, 
    0xd9, 
    0x37, 0x1b, 0x80, 
    0xb0, 
    0x81, 
    0x21, 
    0x80, 
    0xd7, 
    0x37, 0x04, 0x80, 
    0x80, 
    0xb0, 
    0x81, 
    0x27, 
    0xb0, 
    0x83, 
    0x21, 
    0x80, 
    0xd7, 
    0x37, 0x04, 0x80, 
    0x80, 
    0xb0, 
    0x83, 
    0x27, 
    0x35, 0x43, 0x80, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xd7, 
    0x37, 0x1a, 0x80, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0x33, 
    0xb0, 
    0x80, 
    0x27, 
    0xb0, 
    0x82, 
    0x27, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0x33, 
    0xb0, 
    0x81, 
    0x27, 
    0xb0, 
    0x83, 
    0x27, 
    0xb0, 
    0x80, 
    0x31, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xd1, 
    0xb0, 
    0x82, 
    0x21, 
    0xb0, 
    0x80, 
    0x21, 
    0xf2, 
    0xf3, 
    0xb0, 
    0x83, 
    0x21, 
    0xb0, 
    0x81, 
    0x21, 
    0xf2, 
    0xf4, 
    0xe5, 
    0x34, 
    0x27, 
    0x80, 
    0xb0, 
    0x81, 
    0x27, 
    0x35, 0x02, 0x80, 
    0x12, 
    0x5b, 
    0x35, 0xeb, 0x7d, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_clip_line[3] = {
    MP_ROM_QSTR(MP_QSTR_c),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_clip_line = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_clip_line,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_clip_line,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 606,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_power
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_power[34] = {
    0x05, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0a,
    MP_QSTR_set_power & 0xff, MP_QSTR_set_power >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xcd, 0x28, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR_pwr & 0xff, MP_QSTR_pwr >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x8f, 
    0x64, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_power[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_on),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_power = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_power,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_power,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 34,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_orient
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_orient[93] = {
    0x08, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0e,
    MP_QSTR_set_orient & 0xff, MP_QSTR_set_orient >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xd1, 0x50, 0x27, 0x29, 0x2e, 0x2c, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x94, 
    0xb1, 
    0x83, 
    0xee, 
    0x84, 
    0xf1, 
    0x66, 0x03, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_iflush & 0xff, MP_QSTR_iflush >> 8,
    0x66, 0x00, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x02, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__waitfor & 0xff, MP_QSTR__waitfor >> 8,
    0x84, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x85, 
    0x21, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x85, 
    0x21, 
    0x81, 
    0x21, 
    0xb0, 
    0x26, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x85, 
    0x21, 
    0x82, 
    0x21, 
    0xb0, 
    0x26, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_set_orient_0 = {{&mp_type_bytes}, 50896, 3, (const byte*)"\x02\x67\x30"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_orient[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_orient),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_set_orient_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_orient = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_orient,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_orient,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 93,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_brightness
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_brightness[30] = {
    0x07, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09,
    MP_QSTR_set_brightness & 0xff, MP_QSTR_set_brightness >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xda, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x96, 
    0xb1, 
    0x66, 0x03, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_brightness[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_value),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_brightness = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_brightness,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_brightness,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 30,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr[55] = {
    0x09, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0b,
    MP_QSTR_set_i2c_addr & 0xff, MP_QSTR_set_i2c_addr >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xde, 0x26, 0x29, 0x00, 0x00, 0xff,
    0xb1, 
    0x83, 
    0xee, 
    0x37, 0x09, 0x80, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBW & 0xff, MP_QSTR__lt_BBW >> 8,
    0x8e, 
    0x14, 0x82, 0x8c, 0xe4, 0x49, 
    0xb1, 
    0x98, 
    0xef, 
    0xec, 
    0x66, 0x03, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr_0 = {{&mp_type_str}, 21473, 34, (const byte*)"\x6d\x75\x73\x74\x20\x73\x70\x65\x63\x69\x66\x79\x20\x6d\x6f\x64\x20\x34\x20\x61\x6c\x69\x67\x6e\x65\x64\x20\x61\x64\x64\x72\x65\x73\x73"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_addr),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 55,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate[69] = {
    0x08, 0x01, 0x00, 0x02, 0x00, 0x00, 0x0c,
    MP_QSTR_set_uart_baudrate & 0xff, MP_QSTR_set_uart_baudrate >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xe3, 0x23, 0x53, 0x2e, 0x00, 0x00, 0xff,
    0x3f, 0x0a, 0x00, 
    0x1c, MP_QSTR__uart_baud_table & 0xff, MP_QSTR__uart_baud_table >> 8,
    0xb1, 
    0x21, 
    0xc1, 
    0x44, 
    0x35, 0x17, 0x80, 
    0x30, 
    0x1c, MP_QSTR_KeyError & 0xff, MP_QSTR_KeyError >> 8,
    0xdf, 
    0x37, 0x0e, 0x80, 
    0x32, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0x45, 
    0x35, 0x01, 0x80, 
    0x41, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x98, 
    0xb1, 
    0x66, 0x03, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate_0 = {{&mp_type_str}, 2756, 16, (const byte*)"\x69\x6e\x76\x61\x6c\x69\x64\x20\x62\x61\x75\x64\x72\x61\x74\x65"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_baudrate),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 69,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_startup_deco
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_startup_deco[30] = {
    0x07, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09,
    MP_QSTR_set_startup_deco & 0xff, MP_QSTR_set_startup_deco >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xea, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x99, 
    0xb1, 
    0x66, 0x03, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_startup_deco[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_value),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_startup_deco = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_startup_deco,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_startup_deco,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 30,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_save_to_flash
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_save_to_flash[27] = {
    0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x09,
    MP_QSTR_save_to_flash & 0xff, MP_QSTR_save_to_flash >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xed, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x01, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_save_to_flash_0 = {{&mp_type_bytes}, 51055, 3, (const byte*)"\x02\x66\x6e"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_save_to_flash[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_save_to_flash_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_save_to_flash = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_save_to_flash,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_save_to_flash,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 27,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_pixel
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_pixel[34] = {
    0x0b, 0x00, 0x00, 0x04, 0x00, 0x00, 0x09,
    MP_QSTR_set_pixel & 0xff, MP_QSTR_set_pixel >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xf2, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBH & 0xff, MP_QSTR__lt_BBBBH >> 8,
    0x14, 0x80, 0x41, 
    0xb1, 
    0xb2, 
    0xb3, 
    0x66, 0x05, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_pixel[4] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_c),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_pixel = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 4,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_pixel,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_pixel,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 34,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_get_pixel
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_get_pixel[146] = {
    0x0a, 0x00, 0x00, 0x03, 0x00, 0x00, 0x12,
    MP_QSTR_get_pixel & 0xff, MP_QSTR_get_pixel >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x81, 0xf5, 0x2f, 0x24, 0x23, 0x32, 0x2b, 0x34, 0x34, 0x24, 0x2b, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBBB & 0xff, MP_QSTR__lt_BBBB >> 8,
    0x14, 0x80, 0x61, 
    0xb1, 
    0xb2, 
    0x66, 0x04, 
    0x32, 
    0x14, 0x87, 0x68, 
    0xc3, 
    0x35, 0x50, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x80, 
    0x21, 
    0x82, 
    0xdb, 
    0x37, 0x28, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x83, 
    0x21, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x83, 
    0x21, 
    0x81, 
    0x21, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x83, 
    0x21, 
    0x82, 
    0x21, 
    0x88, 
    0xef, 
    0xec, 
    0x5b, 
    0xb3, 
    0x81, 
    0xe6, 
    0xc3, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x81, 
    0x64, 0x01, 
    0x32, 
    0xb3, 
    0x36, 0xac, 0x7f, 
    0x1c, MP_QSTR_OSError & 0xff, MP_QSTR_OSError >> 8,
    0x1c, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x1d, MP_QSTR_ETIMEDOUT & 0xff, MP_QSTR_ETIMEDOUT >> 8,
    0x64, 0x01, 
    0x5c, 0x01, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_get_pixel[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_get_pixel = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_get_pixel,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_get_pixel,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 146,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_get_line
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_get_line[137] = {
    0x0d, 0x00, 0x00, 0x04, 0x00, 0x00, 0x14,
    MP_QSTR_get_line & 0xff, MP_QSTR_get_line >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x01, 0x29, 0x2e, 0x24, 0x24, 0x23, 0x32, 0x2b, 0x2f, 0x22, 0x24, 0x2b, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb3, 
    0x64, 0x01, 
    0x82, 
    0xf4, 
    0xc4, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBB & 0xff, MP_QSTR__lt_BBBBB >> 8,
    0x90, 
    0xb4, 
    0xb1, 
    0xb2, 
    0x66, 0x05, 
    0x32, 
    0xb4, 
    0x82, 
    0xe7, 
    0xc4, 
    0x14, 0x87, 0x68, 
    0xc5, 
    0x35, 0x39, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf1 & 0xff, MP_QSTR_buf1 >> 8,
    0x80, 
    0x21, 
    0xb4, 
    0xdb, 
    0x37, 0x11, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x1e, MP_QSTR_readfrom_into & 0xff, MP_QSTR_readfrom_into >> 8,
    0xb0, 
    0x1d, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0xb3, 
    0x66, 0x02, 
    0x32, 
    0x11, 
    0x5b, 
    0xb5, 
    0x81, 
    0xe6, 
    0xc5, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x81, 
    0x64, 0x01, 
    0x32, 
    0xb5, 
    0x36, 0xc3, 0x7f, 
    0x1c, MP_QSTR_OSError & 0xff, MP_QSTR_OSError >> 8,
    0x1c, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x1d, MP_QSTR_ETIMEDOUT & 0xff, MP_QSTR_ETIMEDOUT >> 8,
    0x64, 0x01, 
    0x5c, 0x01, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_get_line[4] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_buf),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_get_line = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 4,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_get_line,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_get_line,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 137,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_screen_dump
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_screen_dump[263] = {
    0x13, 0x00, 0x00, 0x06, 0x00, 0x04, 0x1b,
    MP_QSTR_screen_dump & 0xff, MP_QSTR_screen_dump >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x0f, 0x26, 0x27, 0x26, 0x27, 0x28, 0x2b, 0x65, 0x26, 0x2b, 0x32, 0x36, 0x26, 0x2c, 0x3a, 0x2b, 0x24, 0x2e, 0x3a, 0x00, 0x00, 0xff,
    0xb4, 
    0x11, 
    0xde, 
    0x37, 0x07, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb2, 
    0xf2, 
    0xc4, 
    0xb5, 
    0x11, 
    0xde, 
    0x37, 0x07, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xb3, 
    0xf2, 
    0xc5, 
    0xb4, 
    0x14, 0x80, 0x7f, 
    0xda, 
    0x37, 0x10, 0x80, 
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0x82, 
    0xb4, 
    0xf3, 
    0x81, 
    0xf1, 
    0x64, 0x01, 
    0xc6, 
    0x11, 
    0xc7, 
    0x35, 0x23, 0x80, 
    0xb4, 
    0x81, 
    0xf1, 
    0x82, 
    0xf4, 
    0xc8, 
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0x82, 
    0xb8, 
    0xf3, 
    0x81, 
    0xf1, 
    0x64, 0x01, 
    0xc6, 
    0x1c, MP_QSTR_memoryview & 0xff, MP_QSTR_memoryview >> 8,
    0xb6, 
    0x64, 0x01, 
    0x11, 
    0x82, 
    0xb4, 
    0xb8, 
    0xf2, 
    0xf3, 
    0x81, 
    0xf1, 
    0x58, 0x02, 
    0x21, 
    0xc7, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0x82, 
    0xb4, 
    0xf3, 
    0xf4, 
    0xb5, 
    0x64, 0x02, 
    0x80, 
    0x35, 0x72, 0x80, 
    0x30, 
    0xc9, 
    0xb9, 
    0xb4, 
    0xf3, 
    0x82, 
    0xf3, 
    0xca, 
    0xb0, 
    0x1e, MP_QSTR_get_line & 0xff, MP_QSTR_get_line >> 8,
    0xb2, 
    0xb3, 
    0xb9, 
    0xf1, 
    0xb6, 
    0x66, 0x03, 
    0x32, 
    0x1c, MP_QSTR_memoryview & 0xff, MP_QSTR_memoryview >> 8,
    0xb6, 
    0x64, 0x01, 
    0x81, 
    0x11, 
    0x58, 0x02, 
    0x21, 
    0xb1, 
    0xba, 
    0xba, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb6, 
    0x64, 0x01, 
    0xf1, 
    0x81, 
    0xf2, 
    0x58, 0x02, 
    0x27, 
    0xba, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb6, 
    0x64, 0x01, 
    0x81, 
    0xf2, 
    0xe5, 
    0xca, 
    0xb7, 
    0x37, 0x33, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_get_line & 0xff, MP_QSTR_get_line >> 8,
    0xb2, 
    0xb8, 
    0xf1, 
    0xb3, 
    0xb9, 
    0xf1, 
    0xb7, 
    0x66, 0x03, 
    0x32, 
    0x1c, MP_QSTR_memoryview & 0xff, MP_QSTR_memoryview >> 8,
    0xb7, 
    0x64, 0x01, 
    0x81, 
    0x11, 
    0x58, 0x02, 
    0x21, 
    0xb1, 
    0xba, 
    0xba, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb7, 
    0x64, 0x01, 
    0xf1, 
    0x81, 
    0xf2, 
    0x58, 0x02, 
    0x27, 
    0xba, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb7, 
    0x64, 0x01, 
    0x81, 
    0xf2, 
    0xe5, 
    0xca, 
    0x81, 
    0xe5, 
    0x31, 
    0x33, 
    0xd7, 
    0x36, 0x88, 0x7f, 
    0x32, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_screen_dump[6] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_buf),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_screen_dump = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 6,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_screen_dump,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_screen_dump,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 263,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_screen_load
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_screen_load[175] = {
    0x0d, 0x00, 0x00, 0x02, 0x00, 0x00, 0x14,
    MP_QSTR_screen_load & 0xff, MP_QSTR_screen_load >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x26, 0x2e, 0x37, 0x22, 0x27, 0x23, 0x2f, 0x31, 0x49, 0x2d, 0x23, 0x29, 0x00, 0x00, 0xff,
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xf3, 
    0x82, 
    0xf3, 
    0x82, 
    0xf1, 
    0xc2, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBHBBB & 0xff, MP_QSTR__lt_BBHBBB >> 8,
    0x14, 0x80, 0x70, 
    0xb2, 
    0x90, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x66, 0x06, 
    0x32, 
    0x80, 
    0xc3, 
    0x1c, MP_QSTR_memoryview & 0xff, MP_QSTR_memoryview >> 8,
    0xb1, 
    0x64, 0x01, 
    0xc4, 
    0x35, 0x56, 0x80, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0xb3, 
    0xf2, 
    0x14, 0x84, 0x00, 
    0xdb, 
    0x37, 0x1a, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb4, 
    0xb3, 
    0xb3, 
    0x14, 0x84, 0x00, 
    0xf1, 
    0x58, 0x02, 
    0x21, 
    0x66, 0x01, 
    0x32, 
    0xb3, 
    0x14, 0x84, 0x00, 
    0xe5, 
    0xc3, 
    0x35, 0x2d, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb4, 
    0xb3, 
    0x11, 
    0x58, 0x02, 
    0x21, 
    0x66, 0x01, 
    0x32, 
    0x35, 0x0d, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x02, 
    0x66, 0x01, 
    0x32, 
    0xb3, 
    0x81, 
    0xe5, 
    0xc3, 
    0xb3, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xf3, 
    0x82, 
    0xf3, 
    0xd7, 
    0x36, 0xe3, 0x7f, 
    0xb3, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0xd7, 
    0x36, 0x9f, 0x7f, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_screen_load_0 = {{&mp_type_bytes}, 46501, 1, (const byte*)"\x00"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_screen_load[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_buf),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_screen_load_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_screen_load = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_screen_load,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_screen_load,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 175,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_pos
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_pos[33] = {
    0x09, 0x00, 0x00, 0x03, 0x00, 0x00, 0x09,
    MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x37, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBBB & 0xff, MP_QSTR__lt_BBBB >> 8,
    0x14, 0x80, 0x58, 
    0xb1, 
    0xb2, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_pos[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_pos = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_pos,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_pos,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 33,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_text_color
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_text_color[33] = {
    0x09, 0x00, 0x00, 0x03, 0x00, 0x00, 0x09,
    MP_QSTR_set_text_color & 0xff, MP_QSTR_set_text_color >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x3a, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBHH & 0xff, MP_QSTR__lt_BBHH >> 8,
    0x14, 0x80, 0x63, 
    0xb1, 
    0xb2, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_text_color[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_fg),
    MP_ROM_QSTR(MP_QSTR_bg),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_text_color = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_text_color,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_text_color,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 33,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_font
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_font[53] = {
    0x0d, 0x00, 0x00, 0x06, 0x00, 0x04, 0x09,
    MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x3d, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBBB & 0xff, MP_QSTR__lt_BBBB >> 8,
    0x14, 0x80, 0x46, 
    0xb5, 
    0x87, 
    0xef, 
    0xb4, 
    0x86, 
    0xef, 
    0xec, 
    0xb1, 
    0x83, 
    0xee, 
    0x84, 
    0xef, 
    0xec, 
    0xb3, 
    0x8f, 
    0xee, 
    0xec, 
    0xb2, 
    0x14, 0x81, 0x7f, 
    0xee, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_font[6] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_font),
    MP_ROM_QSTR(MP_QSTR_scale),
    MP_ROM_QSTR(MP_QSTR_bold),
    MP_ROM_QSTR(MP_QSTR_trans),
    MP_ROM_QSTR(MP_QSTR_scroll),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_font = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 6,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_font,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_font,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 53,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_write
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_write[26] = {
    0x05, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09,
    MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x41, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_write[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_s),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_write = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_write,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_write,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 26,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_pen
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_pen[33] = {
    0x09, 0x00, 0x00, 0x03, 0x00, 0x00, 0x09,
    MP_QSTR_set_pen & 0xff, MP_QSTR_set_pen >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x46, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBHH & 0xff, MP_QSTR__lt_BBHH >> 8,
    0x14, 0x80, 0x50, 
    0xb1, 
    0xb2, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_pen[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_line),
    MP_ROM_QSTR(MP_QSTR_fill),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_pen = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_pen,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_pen,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 33,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_erase
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_erase[27] = {
    0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x09,
    MP_QSTR_erase & 0xff, MP_QSTR_erase >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x49, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x01, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_erase_0 = {{&mp_type_bytes}, 27330, 2, (const byte*)"\x02\x45"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_erase[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_erase_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_erase = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_erase,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_erase,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 27,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_dot
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_dot[77] = {
    0x09, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0b,
    MP_QSTR_dot & 0xff, MP_QSTR_dot >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x4c, 0x1f, 0x2b, 0x00, 0x00, 0xff,
    0x80, 
    0xb1, 
    0x30, 
    0x34, 
    0xda, 
    0x39, 0x08, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xd7, 
    0x35, 0x02, 0x80, 
    0x33, 
    0x32, 
    0x37, 0x24, 0x80, 
    0x80, 
    0xb2, 
    0x30, 
    0x34, 
    0xda, 
    0x39, 0x08, 0x80, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xd7, 
    0x35, 0x02, 0x80, 
    0x33, 
    0x32, 
    0x37, 0x0f, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBBB & 0xff, MP_QSTR__lt_BBBB >> 8,
    0x14, 0x80, 0x4b, 
    0xb1, 
    0xb2, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_dot[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_dot = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_dot,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_dot,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 77,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rect
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect[356] = {
    0x12, 0x00, 0x00, 0x06, 0x00, 0x01, 0x22,
    MP_QSTR_rect & 0xff, MP_QSTR_rect >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x50, 0x1f, 0x23, 0x22, 0x2c, 0x24, 0x26, 0x22, 0x24, 0x22, 0x26, 0x22, 0x24, 0x22, 0x50, 0x1f, 0x22, 0x50, 0x24, 0x39, 0x24, 0x39, 0x2b, 0x3b, 0x2b, 0x5e, 0x00, 0x00, 0xff,
    0xb1, 
    0xb3, 
    0xf1, 
    0x80, 
    0xda, 
    0x36, 0x1a, 0x80, 
    0xb2, 
    0xb4, 
    0xf1, 
    0x80, 
    0xda, 
    0x36, 0x12, 0x80, 
    0xb1, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xdb, 
    0x36, 0x09, 0x80, 
    0xb2, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xdb, 
    0x37, 0x02, 0x80, 
    0x11, 
    0x5b, 
    0xb1, 
    0x80, 
    0xd7, 
    0x36, 0x06, 0x80, 
    0xb2, 
    0x80, 
    0xd7, 
    0x37, 0xea, 0x80, 
    0x12, 
    0x30, 
    0xc6, 
    0xc7, 
    0xb1, 
    0x80, 
    0xd7, 
    0x37, 0x08, 0x80, 
    0x10, 
    0xc6, 
    0xb3, 
    0xb1, 
    0xe5, 
    0xc3, 
    0x80, 
    0xc1, 
    0xb2, 
    0x80, 
    0xd7, 
    0x37, 0x08, 0x80, 
    0x10, 
    0xc7, 
    0xb4, 
    0xb2, 
    0xe5, 
    0xc4, 
    0x80, 
    0xc2, 
    0xb5, 
    0x14, 0x80, 0x51, 
    0xd9, 
    0x36, 0x08, 0x80, 
    0xb5, 
    0x14, 0x80, 0x72, 
    0xd9, 
    0x37, 0x21, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x51, 
    0xb1, 
    0xb2, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb3, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb4, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x66, 0x06, 
    0x32, 
    0xb5, 
    0x14, 0x80, 0x57, 
    0xd9, 
    0x36, 0x08, 0x80, 
    0xb5, 
    0x14, 0x80, 0x72, 
    0xd9, 
    0x37, 0x86, 0x80, 
    0xb6, 
    0x37, 0x19, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x57, 
    0xb1, 
    0xb2, 
    0x81, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb4, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x66, 0x06, 
    0x32, 
    0xb7, 
    0x37, 0x19, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x57, 
    0xb1, 
    0xb2, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb3, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x81, 
    0x66, 0x06, 
    0x32, 
    0xb1, 
    0xb3, 
    0xf1, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xd7, 
    0x37, 0x1b, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x57, 
    0xb1, 
    0xb3, 
    0xf1, 
    0xb2, 
    0x81, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb4, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x66, 0x06, 
    0x32, 
    0xb2, 
    0xb4, 
    0xf1, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xd7, 
    0x37, 0x1b, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x57, 
    0xb1, 
    0xb2, 
    0xb4, 
    0xf1, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb3, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x81, 
    0x66, 0x06, 
    0x32, 
    0x35, 0x1f, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0xb5, 
    0xb1, 
    0xb2, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb3, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x1c, MP_QSTR_min & 0xff, MP_QSTR_min >> 8,
    0xb4, 
    0x14, 0x81, 0x7f, 
    0x64, 0x02, 
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect[6] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
    MP_ROM_QSTR(MP_QSTR_cmd),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rect = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 6,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 356,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rect_outline
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline[32] = {
    0x0c, 0x00, 0x00, 0x05, 0x00, 0x00, 0x09,
    MP_QSTR_rect_outline & 0xff, MP_QSTR_rect_outline >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x6d, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR_rect & 0xff, MP_QSTR_rect >> 8,
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x14, 0x80, 0x57, 
    0x66, 0x05, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_outline = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 32,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rect_interior
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior[32] = {
    0x0c, 0x00, 0x00, 0x05, 0x00, 0x00, 0x09,
    MP_QSTR_rect_interior & 0xff, MP_QSTR_rect_interior >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x70, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR_rect & 0xff, MP_QSTR_rect >> 8,
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x14, 0x80, 0x51, 
    0x66, 0x05, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_interior = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 32,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_line
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_line[88] = {
    0x0f, 0x00, 0x00, 0x05, 0x00, 0x00, 0x0f,
    MP_QSTR_line & 0xff, MP_QSTR_line >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x73, 0x25, 0x24, 0x24, 0x24, 0x24, 0x32, 0x00, 0x00, 0xff,
    0xb0, 
    0x1d, MP_QSTR_array4 & 0xff, MP_QSTR_array4 >> 8,
    0xc5, 
    0xb1, 
    0xb5, 
    0x80, 
    0x27, 
    0xb2, 
    0xb5, 
    0x81, 
    0x27, 
    0xb3, 
    0xb5, 
    0x82, 
    0x27, 
    0xb4, 
    0xb5, 
    0x83, 
    0x27, 
    0xb0, 
    0x1e, MP_QSTR_clip_line & 0xff, MP_QSTR_clip_line >> 8,
    0xb5, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x66, 0x03, 
    0x37, 0x19, 0x80, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x4c, 
    0xb5, 
    0x80, 
    0x21, 
    0xb5, 
    0x81, 
    0x21, 
    0xb5, 
    0x82, 
    0x21, 
    0xb5, 
    0x83, 
    0x21, 
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_line[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x1),
    MP_ROM_QSTR(MP_QSTR_y1),
    MP_ROM_QSTR(MP_QSTR_x2),
    MP_ROM_QSTR(MP_QSTR_y2),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_line = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_line,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_line,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 88,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_dot_no_clip
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_dot_no_clip[33] = {
    0x09, 0x00, 0x00, 0x03, 0x00, 0x00, 0x09,
    MP_QSTR_dot_no_clip & 0xff, MP_QSTR_dot_no_clip >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x7c, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBBB & 0xff, MP_QSTR__lt_BBBB >> 8,
    0x14, 0x80, 0x4b, 
    0xb1, 
    0xb2, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_dot_no_clip[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_dot_no_clip = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 3,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_dot_no_clip,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_dot_no_clip,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 33,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rect_no_clip
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_no_clip[35] = {
    0x0d, 0x00, 0x00, 0x05, 0x00, 0x00, 0x09,
    MP_QSTR_rect_no_clip & 0xff, MP_QSTR_rect_no_clip >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x7f, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x72, 
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_no_clip[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_no_clip = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_no_clip,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_no_clip,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 35,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip[35] = {
    0x0d, 0x00, 0x00, 0x05, 0x00, 0x00, 0x09,
    MP_QSTR_rect_outline_no_clip & 0xff, MP_QSTR_rect_outline_no_clip >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x82, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x57, 
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 35,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip[35] = {
    0x0d, 0x00, 0x00, 0x05, 0x00, 0x00, 0x09,
    MP_QSTR_rect_interior_no_clip & 0xff, MP_QSTR_rect_interior_no_clip >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x85, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x51, 
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 35,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_line_no_clip
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_line_no_clip[35] = {
    0x0d, 0x00, 0x00, 0x05, 0x00, 0x00, 0x09,
    MP_QSTR_line_no_clip & 0xff, MP_QSTR_line_no_clip >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x88, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBBB & 0xff, MP_QSTR__lt_BBBBBB >> 8,
    0x14, 0x80, 0x4c, 
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0x66, 0x06, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_line_no_clip[5] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x1),
    MP_ROM_QSTR(MP_QSTR_y1),
    MP_ROM_QSTR(MP_QSTR_x2),
    MP_ROM_QSTR(MP_QSTR_y2),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_line_no_clip = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_line_no_clip,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_line_no_clip,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 35,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_poly_dot
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_poly_dot[70] = {
    0x08, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0c,
    MP_QSTR_poly_dot & 0xff, MP_QSTR_poly_dot >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x8b, 0x2b, 0x29, 0x35, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0x81, 
    0xee, 
    0x37, 0x09, 0x80, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x14, 0x80, 0x71, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0x82, 
    0xf4, 
    0x66, 0x03, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_poly_dot_0 = {{&mp_type_str}, 57570, 33, (const byte*)"\x6d\x75\x73\x74\x20\x73\x70\x65\x63\x69\x66\x79\x20\x65\x76\x65\x6e\x20\x6e\x75\x6d\x62\x65\x72\x20\x6f\x66\x20\x62\x79\x74\x65\x73"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_poly_dot[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_data),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_poly_dot_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_poly_dot = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_poly_dot,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_poly_dot,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 70,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_poly_line
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_poly_line[70] = {
    0x08, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0c,
    MP_QSTR_poly_line & 0xff, MP_QSTR_poly_line >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x91, 0x2b, 0x29, 0x35, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0x81, 
    0xee, 
    0x37, 0x09, 0x80, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x14, 0x80, 0x78, 
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0x82, 
    0xf4, 
    0x66, 0x03, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_poly_line_0 = {{&mp_type_str}, 57570, 33, (const byte*)"\x6d\x75\x73\x74\x20\x73\x70\x65\x63\x69\x66\x79\x20\x65\x76\x65\x6e\x20\x6e\x75\x6d\x62\x65\x72\x20\x6f\x66\x20\x62\x79\x74\x65\x73"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_poly_line[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_data),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_poly_line_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_poly_line = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_poly_line,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_poly_line,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 70,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_touch_config
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_touch_config[51] = {
    0x0b, 0x00, 0x00, 0x04, 0x00, 0x03, 0x09,
    MP_QSTR_touch_config & 0xff, MP_QSTR_touch_config >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x99, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBBB & 0xff, MP_QSTR__lt_BBBB >> 8,
    0x14, 0x80, 0x7a, 
    0xb3, 
    0x11, 
    0xde, 
    0xd3, 
    0x82, 
    0xef, 
    0xb2, 
    0x81, 
    0xef, 
    0xec, 
    0xb1, 
    0xec, 
    0x1c, MP_QSTR_bool & 0xff, MP_QSTR_bool >> 8,
    0xb3, 
    0x64, 0x01, 
    0x87, 
    0xef, 
    0x66, 0x04, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_touch_config[4] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_calib),
    MP_ROM_QSTR(MP_QSTR_save),
    MP_ROM_QSTR(MP_QSTR_irq),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_touch_config = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 4,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_touch_config,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_touch_config,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 51,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_is_touched
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_is_touched[52] = {
    0x06, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0c,
    MP_QSTR_is_touched & 0xff, MP_QSTR_is_touched >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0x9c, 0x29, 0x27, 0x29, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x01, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x84, 
    0x21, 
    0xc1, 
    0xb0, 
    0x1e, MP_QSTR__waitfor & 0xff, MP_QSTR__waitfor >> 8,
    0x83, 
    0xb1, 
    0x66, 0x02, 
    0x32, 
    0xb1, 
    0x81, 
    0x21, 
    0x87, 
    0xf0, 
    0x80, 
    0xdc, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_is_touched_0 = {{&mp_type_bytes}, 27347, 2, (const byte*)"\x02\x54"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_is_touched[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_is_touched_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_is_touched = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_is_touched,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_is_touched,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 52,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_get_touch
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_get_touch[58] = {
    0x06, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0c,
    MP_QSTR_get_touch & 0xff, MP_QSTR_get_touch >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xa2, 0x29, 0x27, 0x29, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x01, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_buf & 0xff, MP_QSTR_buf >> 8,
    0x84, 
    0x21, 
    0xc1, 
    0xb0, 
    0x1e, MP_QSTR__waitfor & 0xff, MP_QSTR__waitfor >> 8,
    0x83, 
    0xb1, 
    0x66, 0x02, 
    0x32, 
    0xb1, 
    0x81, 
    0x21, 
    0x87, 
    0xf0, 
    0xb1, 
    0x82, 
    0x21, 
    0xb1, 
    0x83, 
    0x21, 
    0x50, 0x03, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_get_touch_0 = {{&mp_type_bytes}, 27347, 2, (const byte*)"\x02\x54"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_get_touch[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_get_touch_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_get_touch = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_get_touch,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_get_touch,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 58,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_spi_win
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_spi_win[68] = {
    0x14, 0x00, 0x00, 0x05, 0x00, 0x00, 0x0b,
    MP_QSTR_set_spi_win & 0xff, MP_QSTR_set_spi_win >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xaa, 0x1f, 0x26, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0x17, 0x05, 
    0xb0, 
    0x1d, MP_QSTR_buf19 & 0xff, MP_QSTR_buf19 >> 8,
    0x80, 
    0x82, 
    0x14, 0x80, 0x55, 
    0x8a, 
    0xb1, 
    0xb2, 
    0xb1, 
    0xb3, 
    0xf1, 
    0x81, 
    0xf2, 
    0xb2, 
    0xb4, 
    0xf1, 
    0x81, 
    0xf2, 
    0x80, 
    0x80, 
    0x80, 
    0x14, 0x83, 0xff, 0x7f, 
    0x64, 0x0e, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf19 & 0xff, MP_QSTR_buf19 >> 8,
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_set_spi_win_0 = {{&mp_type_str}, 4731, 12, (const byte*)"\x3c\x42\x42\x42\x48\x48\x48\x48\x48\x48\x48\x48"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_spi_win[6] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_set_spi_win_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_spi_win = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 5,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_spi_win,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_spi_win,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 68,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_fast_spi
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_fast_spi[44] = {
    0x05, 0x00, 0x00, 0x02, 0x00, 0x01, 0x0c,
    MP_QSTR_fast_spi & 0xff, MP_QSTR_fast_spi >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xae, 0x24, 0x27, 0x29, 0x00, 0x00, 0xff,
    0xb1, 
    0x37, 0x07, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_oflush & 0xff, MP_QSTR_oflush >> 8,
    0x66, 0x00, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x02, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_spi & 0xff, MP_QSTR_spi >> 8,
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_fast_spi_0 = {{&mp_type_bytes}, 27285, 2, (const byte*)"\x02\x12"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_fast_spi[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_flush),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_fast_spi_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_fast_spi = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_fast_spi,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_fast_spi,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 44,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_show_framebuf
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_show_framebuf[31] = {
    0x05, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09,
    MP_QSTR_show_framebuf & 0xff, MP_QSTR_show_framebuf >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xb4, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR_fast_spi & 0xff, MP_QSTR_fast_spi >> 8,
    0x66, 0x00, 
    0x1e, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_show_framebuf[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_buf),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_show_framebuf = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_show_framebuf,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_show_framebuf,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 31,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_scroll
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll[30] = {
    0x07, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09,
    MP_QSTR_set_scroll & 0xff, MP_QSTR_set_scroll >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xb7, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x95, 
    0xb1, 
    0x66, 0x03, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_on),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 30,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_scroll_win
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win[56] = {
    0x19, 0x00, 0x00, 0x0a, 0x00, 0x08, 0x0a,
    MP_QSTR_set_scroll_win & 0xff, MP_QSTR_set_scroll_win >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xba, 0x3a, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0x17, 0x0a, 
    0xb0, 
    0x1d, MP_QSTR_buf19 & 0xff, MP_QSTR_buf19 >> 8,
    0x80, 
    0x82, 
    0x14, 0x80, 0x55, 
    0xb1, 
    0xb2, 
    0xb3, 
    0xb4, 
    0xb5, 
    0xb6, 
    0xb7, 
    0xb8, 
    0xb9, 
    0x64, 0x0e, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb0, 
    0x1d, MP_QSTR_buf19 & 0xff, MP_QSTR_buf19 >> 8,
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_0 = {{&mp_type_str}, 4731, 12, (const byte*)"\x3c\x42\x42\x42\x48\x48\x48\x48\x48\x48\x48\x48"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win[11] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_win),
    MP_ROM_QSTR(MP_QSTR_x),
    MP_ROM_QSTR(MP_QSTR_y),
    MP_ROM_QSTR(MP_QSTR_w),
    MP_ROM_QSTR(MP_QSTR_h),
    MP_ROM_QSTR(MP_QSTR_vec),
    MP_ROM_QSTR(MP_QSTR_pat),
    MP_ROM_QSTR(MP_QSTR_fill),
    MP_ROM_QSTR(MP_QSTR_color),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 10,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 56,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param[34] = {
    0x0b, 0x00, 0x00, 0x04, 0x00, 0x00, 0x09,
    MP_QSTR_set_scroll_win_param & 0xff, MP_QSTR_set_scroll_win_param >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xbe, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x16, MP_QSTR__lt_BBBBH & 0xff, MP_QSTR__lt_BBBBH >> 8,
    0x14, 0x80, 0x75, 
    0xb1, 
    0xb2, 
    0xb3, 
    0x66, 0x05, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param[4] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_win),
    MP_ROM_QSTR(MP_QSTR_param),
    MP_ROM_QSTR(MP_QSTR_value),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 4,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 34,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf[64] = {
    0x08, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0d,
    MP_QSTR_set_scroll_buf & 0xff, MP_QSTR_set_scroll_buf >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xc1, 0x27, 0x26, 0x29, 0x2c, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0xc2, 
    0xb2, 
    0xa0, 
    0xd8, 
    0x37, 0x09, 0x80, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBB & 0xff, MP_QSTR__lt_BBB >> 8,
    0x91, 
    0xb2, 
    0x66, 0x03, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf_0 = {{&mp_type_str}, 32372, 25, (const byte*)"\x6c\x65\x6e\x67\x74\x68\x20\x6d\x75\x73\x74\x20\x62\x65\x20\x33\x32\x20\x6f\x72\x20\x6c\x65\x73\x73"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_s),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 64,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_jpeg_start
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_start[60] = {
    0x07, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0c,
    MP_QSTR_jpeg_start & 0xff, MP_QSTR_jpeg_start >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xc8, 0x29, 0x29, 0x27, 0x00, 0x00, 0xff,
    0xb1, 
    0x14, 0x83, 0xff, 0x7f, 
    0xd8, 
    0x37, 0x09, 0x80, 
    0x1c, MP_QSTR_ValueError & 0xff, MP_QSTR_ValueError >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x5c, 0x01, 
    0xb0, 
    0x1e, MP_QSTR_oflush & 0xff, MP_QSTR_oflush >> 8,
    0x66, 0x00, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x16, MP_QSTR__lt_BBH & 0xff, MP_QSTR__lt_BBH >> 8,
    0x14, 0x80, 0x6a, 
    0xb1, 
    0x66, 0x03, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_jpeg_start_0 = {{&mp_type_str}, 9605, 28, (const byte*)"\x6c\x65\x6e\x67\x74\x68\x20\x6d\x75\x73\x74\x20\x62\x65\x20\x36\x35\x35\x33\x35\x20\x6f\x72\x20\x6c\x65\x73\x73"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_start[3] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_l),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_jpeg_start_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_jpeg_start = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_start,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_start,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 60,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_jpeg_data
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_data[26] = {
    0x05, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09,
    MP_QSTR_jpeg_data & 0xff, MP_QSTR_jpeg_data >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xce, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_data[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_buf),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_jpeg_data = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_data,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_jpeg_data,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 26,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_jpeg
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_jpeg[40] = {
    0x06, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0a,
    MP_QSTR_jpeg & 0xff, MP_QSTR_jpeg >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xd1, 0x2d, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR_jpeg_start & 0xff, MP_QSTR_jpeg_start >> 8,
    0x1c, MP_QSTR_len & 0xff, MP_QSTR_len >> 8,
    0xb1, 
    0x64, 0x01, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_jpeg_data & 0xff, MP_QSTR_jpeg_data >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_jpeg[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_QSTR(MP_QSTR_buf),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_jpeg = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_jpeg,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_jpeg,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 40,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_feed_wdt
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_feed_wdt[27] = {
    0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x09,
    MP_QSTR_feed_wdt & 0xff, MP_QSTR_feed_wdt >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xd5, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x01, 
    0x66, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_feed_wdt_0 = {{&mp_type_bytes}, 27280, 2, (const byte*)"\x02\x17"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_feed_wdt[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_feed_wdt_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_feed_wdt = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_feed_wdt,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_feed_wdt,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 27,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR_reset
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR_reset[35] = {
    0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a,
    MP_QSTR_reset & 0xff, MP_QSTR_reset >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x91, 0xd8, 0x29, 0x00, 0x00, 0xff,
    0xb0, 
    0x1e, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x17, 0x01, 
    0x66, 0x01, 
    0x32, 
    0x1c, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x8f, 
    0x64, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr__lt_module_gt__LCD160CR_reset_0 = {{&mp_type_bytes}, 28220, 6, (const byte*)"\x02\x59\xef\xbe\xad\xde"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR_reset[2] = {
    MP_ROM_QSTR(MP_QSTR_self),
    MP_ROM_PTR(&const_obj_lcd160cr__lt_module_gt__LCD160CR_reset_0),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR_reset = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR_reset,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR_reset,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 35,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr__lt_module_gt__LCD160CR
STATIC const byte bytecode_data_lcd160cr__lt_module_gt__LCD160CR[481] = {
    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f,
    MP_QSTR_LCD160CR & 0xff, MP_QSTR_LCD160CR >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x8d, 0x20, 0x1f, 0x81, 0x2f, 0x85, 0x0c, 0x6a, 0x40, 0x69, 0x40, 0x85, 0x0b, 0x8b, 0x0b, 0x85, 0x0c, 0x6a, 0x20, 0x8a, 0x41, 0x65, 0x20, 0x85, 0x09, 0x65, 0x65, 0x60, 0x85, 0x07, 0x65, 0x65, 0x40, 0x65, 0x85, 0x0c, 0x85, 0x0e, 0x8c, 0x17, 0x85, 0x11, 0x65, 0x65, 0x6c, 0x65, 0x60, 0x65, 0x65, 0x65, 0x20, 0x8b, 0x1d, 0x65, 0x65, 0x85, 0x09, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x60, 0x85, 0x08, 0x6b, 0x65, 0x60, 0x85, 0x08, 0x65, 0x20, 0x69, 0x60, 0x65, 0x65, 0x72, 0x20, 0x65, 0x85, 0x07, 0x65, 0x60, 0x65, 0x65, 0x20, 0x65, 0x00, 0x00, 0xff,
    0x1b, MP_QSTR___name__ & 0xff, MP_QSTR___name__ >> 8,
    0x24, MP_QSTR___module__ & 0xff, MP_QSTR___module__ >> 8,
    0x16, MP_QSTR_LCD160CR & 0xff, MP_QSTR_LCD160CR >> 8,
    0x24, MP_QSTR___qualname__ & 0xff, MP_QSTR___qualname__ >> 8,
    0x11, 
    0x50, 0x01, 
    0x53, 0x00, 
    0x11, 
    0x16, MP_QSTR_pwr & 0xff, MP_QSTR_pwr >> 8,
    0x54, 
    0x11, 
    0x16, MP_QSTR_i2c & 0xff, MP_QSTR_i2c >> 8,
    0x54, 
    0x11, 
    0x16, MP_QSTR_spi & 0xff, MP_QSTR_spi >> 8,
    0x54, 
    0x14, 0x80, 0x62, 
    0x16, MP_QSTR_i2c_addr & 0xff, MP_QSTR_i2c_addr >> 8,
    0x54, 
    0x61, 0x00, 
    0x24, MP_QSTR___init__ & 0xff, MP_QSTR___init__ >> 8,
    0x60, 0x01, 
    0x24, MP_QSTR__send & 0xff, MP_QSTR__send >> 8,
    0x80, 
    0x80, 
    0x50, 0x02, 
    0x18, 
    0x61, 0x02, 
    0x24, MP_QSTR__fcmd2 & 0xff, MP_QSTR__fcmd2 >> 8,
    0x80, 
    0x50, 0x01, 
    0x18, 
    0x61, 0x03, 
    0x24, MP_QSTR__fcmd2b & 0xff, MP_QSTR__fcmd2b >> 8,
    0x60, 0x04, 
    0x24, MP_QSTR__waitfor & 0xff, MP_QSTR__waitfor >> 8,
    0x14, 0x81, 0x7f, 
    0x50, 0x01, 
    0x18, 
    0x61, 0x05, 
    0x24, MP_QSTR_oflush & 0xff, MP_QSTR_oflush >> 8,
    0x60, 0x06, 
    0x24, MP_QSTR_iflush & 0xff, MP_QSTR_iflush >> 8,
    0x1b, MP_QSTR_staticmethod & 0xff, MP_QSTR_staticmethod >> 8,
    0x60, 0x07, 
    0x64, 0x01, 
    0x24, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x1b, MP_QSTR_staticmethod & 0xff, MP_QSTR_staticmethod >> 8,
    0x60, 0x08, 
    0x64, 0x01, 
    0x24, MP_QSTR_clip_line & 0xff, MP_QSTR_clip_line >> 8,
    0x60, 0x09, 
    0x24, MP_QSTR_set_power & 0xff, MP_QSTR_set_power >> 8,
    0x60, 0x0a, 
    0x24, MP_QSTR_set_orient & 0xff, MP_QSTR_set_orient >> 8,
    0x60, 0x0b, 
    0x24, MP_QSTR_set_brightness & 0xff, MP_QSTR_set_brightness >> 8,
    0x60, 0x0c, 
    0x24, MP_QSTR_set_i2c_addr & 0xff, MP_QSTR_set_i2c_addr >> 8,
    0x60, 0x0d, 
    0x24, MP_QSTR_set_uart_baudrate & 0xff, MP_QSTR_set_uart_baudrate >> 8,
    0x60, 0x0e, 
    0x24, MP_QSTR_set_startup_deco & 0xff, MP_QSTR_set_startup_deco >> 8,
    0x60, 0x0f, 
    0x24, MP_QSTR_save_to_flash & 0xff, MP_QSTR_save_to_flash >> 8,
    0x60, 0x10, 
    0x24, MP_QSTR_set_pixel & 0xff, MP_QSTR_set_pixel >> 8,
    0x60, 0x11, 
    0x24, MP_QSTR_get_pixel & 0xff, MP_QSTR_get_pixel >> 8,
    0x60, 0x12, 
    0x24, MP_QSTR_get_line & 0xff, MP_QSTR_get_line >> 8,
    0x80, 
    0x80, 
    0x11, 
    0x11, 
    0x50, 0x04, 
    0x18, 
    0x61, 0x13, 
    0x24, MP_QSTR_screen_dump & 0xff, MP_QSTR_screen_dump >> 8,
    0x60, 0x14, 
    0x24, MP_QSTR_screen_load & 0xff, MP_QSTR_screen_load >> 8,
    0x60, 0x15, 
    0x24, MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    0x60, 0x16, 
    0x24, MP_QSTR_set_text_color & 0xff, MP_QSTR_set_text_color >> 8,
    0x80, 
    0x80, 
    0x80, 
    0x80, 
    0x50, 0x04, 
    0x18, 
    0x61, 0x17, 
    0x24, MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    0x60, 0x18, 
    0x24, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0x60, 0x19, 
    0x24, MP_QSTR_set_pen & 0xff, MP_QSTR_set_pen >> 8,
    0x60, 0x1a, 
    0x24, MP_QSTR_erase & 0xff, MP_QSTR_erase >> 8,
    0x60, 0x1b, 
    0x24, MP_QSTR_dot & 0xff, MP_QSTR_dot >> 8,
    0x14, 0x80, 0x72, 
    0x50, 0x01, 
    0x18, 
    0x61, 0x1c, 
    0x24, MP_QSTR_rect & 0xff, MP_QSTR_rect >> 8,
    0x60, 0x1d, 
    0x24, MP_QSTR_rect_outline & 0xff, MP_QSTR_rect_outline >> 8,
    0x60, 0x1e, 
    0x24, MP_QSTR_rect_interior & 0xff, MP_QSTR_rect_interior >> 8,
    0x60, 0x1f, 
    0x24, MP_QSTR_line & 0xff, MP_QSTR_line >> 8,
    0x60, 0x20, 
    0x24, MP_QSTR_dot_no_clip & 0xff, MP_QSTR_dot_no_clip >> 8,
    0x60, 0x21, 
    0x24, MP_QSTR_rect_no_clip & 0xff, MP_QSTR_rect_no_clip >> 8,
    0x60, 0x22, 
    0x24, MP_QSTR_rect_outline_no_clip & 0xff, MP_QSTR_rect_outline_no_clip >> 8,
    0x60, 0x23, 
    0x24, MP_QSTR_rect_interior_no_clip & 0xff, MP_QSTR_rect_interior_no_clip >> 8,
    0x60, 0x24, 
    0x24, MP_QSTR_line_no_clip & 0xff, MP_QSTR_line_no_clip >> 8,
    0x60, 0x25, 
    0x24, MP_QSTR_poly_dot & 0xff, MP_QSTR_poly_dot >> 8,
    0x60, 0x26, 
    0x24, MP_QSTR_poly_line & 0xff, MP_QSTR_poly_line >> 8,
    0x10, 
    0x10, 
    0x11, 
    0x50, 0x03, 
    0x18, 
    0x61, 0x27, 
    0x24, MP_QSTR_touch_config & 0xff, MP_QSTR_touch_config >> 8,
    0x60, 0x28, 
    0x24, MP_QSTR_is_touched & 0xff, MP_QSTR_is_touched >> 8,
    0x60, 0x29, 
    0x24, MP_QSTR_get_touch & 0xff, MP_QSTR_get_touch >> 8,
    0x60, 0x2a, 
    0x24, MP_QSTR_set_spi_win & 0xff, MP_QSTR_set_spi_win >> 8,
    0x12, 
    0x50, 0x01, 
    0x18, 
    0x61, 0x2b, 
    0x24, MP_QSTR_fast_spi & 0xff, MP_QSTR_fast_spi >> 8,
    0x60, 0x2c, 
    0x24, MP_QSTR_show_framebuf & 0xff, MP_QSTR_show_framebuf >> 8,
    0x60, 0x2d, 
    0x24, MP_QSTR_set_scroll & 0xff, MP_QSTR_set_scroll >> 8,
    0x7f, 
    0x80, 
    0x80, 
    0x80, 
    0x80, 
    0x80, 
    0x14, 0x8f, 0x60, 
    0x80, 
    0x50, 0x08, 
    0x18, 
    0x61, 0x2e, 
    0x24, MP_QSTR_set_scroll_win & 0xff, MP_QSTR_set_scroll_win >> 8,
    0x60, 0x2f, 
    0x24, MP_QSTR_set_scroll_win_param & 0xff, MP_QSTR_set_scroll_win_param >> 8,
    0x60, 0x30, 
    0x24, MP_QSTR_set_scroll_buf & 0xff, MP_QSTR_set_scroll_buf >> 8,
    0x60, 0x31, 
    0x24, MP_QSTR_jpeg_start & 0xff, MP_QSTR_jpeg_start >> 8,
    0x60, 0x32, 
    0x24, MP_QSTR_jpeg_data & 0xff, MP_QSTR_jpeg_data >> 8,
    0x60, 0x33, 
    0x24, MP_QSTR_jpeg & 0xff, MP_QSTR_jpeg >> 8,
    0x60, 0x34, 
    0x24, MP_QSTR_feed_wdt & 0xff, MP_QSTR_feed_wdt >> 8,
    0x60, 0x35, 
    0x24, MP_QSTR_reset & 0xff, MP_QSTR_reset >> 8,
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt__LCD160CR[54] = {
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR___init__),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR__send),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR__fcmd2),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR__fcmd2b),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR__waitfor),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_oflush),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_iflush),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rgb),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_clip_line),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_power),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_orient),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_brightness),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_i2c_addr),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_uart_baudrate),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_startup_deco),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_save_to_flash),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_pixel),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_get_pixel),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_get_line),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_screen_dump),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_screen_load),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_pos),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_text_color),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_font),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_write),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_pen),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_erase),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_dot),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rect),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_outline),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_interior),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_line),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_dot_no_clip),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_no_clip),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_outline_no_clip),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_rect_interior_no_clip),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_line_no_clip),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_poly_dot),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_poly_line),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_touch_config),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_is_touched),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_get_touch),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_spi_win),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_fast_spi),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_show_framebuf),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll_win_param),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_set_scroll_buf),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_jpeg_start),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_jpeg_data),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_jpeg),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_feed_wdt),
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR_reset),
};
STATIC const mp_raw_code_t raw_code_lcd160cr__lt_module_gt__LCD160CR = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 0,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt__LCD160CR,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt__LCD160CR,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 481,
        .n_obj = 0,
        .n_raw_code = 54,
        #endif
    },
};

// frozen bytecode for file lcd160cr.py, scope lcd160cr_<module>
STATIC const byte bytecode_data_lcd160cr__lt_module_gt_[207] = {
    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d,
    MP_QSTR__lt_module_gt_ & 0xff, MP_QSTR__lt_module_gt_ >> 8,
    MP_QSTR_lcd160cr_dot_py & 0xff, MP_QSTR_lcd160cr_dot_py >> 8,
    0x61, 0x30, 0x30, 0x39, 0x70, 0x24, 0x24, 0x24, 0x64, 0x24, 0x24, 0x44, 0x22, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x69, 0x00, 0x00, 0xff,
    0x80, 
    0x16, MP_QSTR_const & 0xff, MP_QSTR_const >> 8,
    0x50, 0x01, 
    0x68, MP_QSTR_micropython & 0xff, MP_QSTR_micropython >> 8,
    0x69, MP_QSTR_const & 0xff, MP_QSTR_const >> 8,
    0x24, MP_QSTR_const & 0xff, MP_QSTR_const >> 8,
    0x32, 
    0x80, 
    0x16, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x50, 0x01, 
    0x68, MP_QSTR_utime & 0xff, MP_QSTR_utime >> 8,
    0x69, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x24, MP_QSTR_sleep_ms & 0xff, MP_QSTR_sleep_ms >> 8,
    0x32, 
    0x80, 
    0x16, MP_QSTR_calcsize & 0xff, MP_QSTR_calcsize >> 8,
    0x16, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0x50, 0x02, 
    0x68, MP_QSTR_ustruct & 0xff, MP_QSTR_ustruct >> 8,
    0x69, MP_QSTR_calcsize & 0xff, MP_QSTR_calcsize >> 8,
    0x24, MP_QSTR_calcsize & 0xff, MP_QSTR_calcsize >> 8,
    0x69, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0x24, MP_QSTR_pack_into & 0xff, MP_QSTR_pack_into >> 8,
    0x32, 
    0x80, 
    0x11, 
    0x68, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x24, MP_QSTR_uerrno & 0xff, MP_QSTR_uerrno >> 8,
    0x80, 
    0x11, 
    0x68, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x24, MP_QSTR_machine & 0xff, MP_QSTR_machine >> 8,
    0x80, 
    0x24, MP_QSTR_PORTRAIT & 0xff, MP_QSTR_PORTRAIT >> 8,
    0x81, 
    0x24, MP_QSTR_LANDSCAPE & 0xff, MP_QSTR_LANDSCAPE >> 8,
    0x82, 
    0x24, MP_QSTR_PORTRAIT_UPSIDEDOWN & 0xff, MP_QSTR_PORTRAIT_UPSIDEDOWN >> 8,
    0x83, 
    0x24, MP_QSTR_LANDSCAPE_UPSIDEDOWN & 0xff, MP_QSTR_LANDSCAPE_UPSIDEDOWN >> 8,
    0x80, 
    0x24, MP_QSTR_STARTUP_DECO_NONE & 0xff, MP_QSTR_STARTUP_DECO_NONE >> 8,
    0x81, 
    0x24, MP_QSTR_STARTUP_DECO_MLOGO & 0xff, MP_QSTR_STARTUP_DECO_MLOGO >> 8,
    0x82, 
    0x24, MP_QSTR_STARTUP_DECO_INFO & 0xff, MP_QSTR_STARTUP_DECO_INFO >> 8,
    0x53, 0x09, 
    0x80, 
    0x14, 0x92, 0x60, 
    0x54, 
    0x81, 
    0x14, 0xa5, 0x40, 
    0x54, 
    0x82, 
    0x14, 0x80, 0xcb, 0x00, 
    0x54, 
    0x83, 
    0x14, 0x81, 0x96, 0x00, 
    0x54, 
    0x84, 
    0x14, 0x82, 0xac, 0x00, 
    0x54, 
    0x85, 
    0x14, 0x83, 0xc2, 0x00, 
    0x54, 
    0x86, 
    0x14, 0x87, 0x84, 0x00, 
    0x54, 
    0x87, 
    0x14, 0x8e, 0x88, 0x00, 
    0x54, 
    0x88, 
    0x14, 0x9c, 0x90, 0x00, 
    0x54, 
    0x24, MP_QSTR__uart_baud_table & 0xff, MP_QSTR__uart_baud_table >> 8,
    0x20, 
    0x60, 0x00, 
    0x16, MP_QSTR_LCD160CR & 0xff, MP_QSTR_LCD160CR >> 8,
    0x64, 0x02, 
    0x24, MP_QSTR_LCD160CR & 0xff, MP_QSTR_LCD160CR >> 8,
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr__lt_module_gt_[1] = {
    MP_ROM_PTR(&raw_code_lcd160cr__lt_module_gt__LCD160CR),
};
const mp_raw_code_t raw_code_lcd160cr__lt_module_gt_ = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 0,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr__lt_module_gt_,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr__lt_module_gt_,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 207,
        .n_obj = 0,
        .n_raw_code = 1,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test__lt_module_gt__get_lcd
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt__get_lcd[43] = {
    0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0b,
    MP_QSTR_get_lcd & 0xff, MP_QSTR_get_lcd >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x61, 0x60, 0x2d, 0x2a, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_type & 0xff, MP_QSTR_type >> 8,
    0xb0, 
    0x64, 0x01, 
    0x1c, MP_QSTR_str & 0xff, MP_QSTR_str >> 8,
    0xde, 
    0x37, 0x0a, 0x80, 
    0x1c, MP_QSTR_lcd160cr & 0xff, MP_QSTR_lcd160cr >> 8,
    0x1e, MP_QSTR_LCD160CR & 0xff, MP_QSTR_LCD160CR >> 8,
    0xb0, 
    0x66, 0x01, 
    0xc0, 
    0xb0, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt__get_lcd[1] = {
    MP_ROM_QSTR(MP_QSTR_lcd),
};
STATIC const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt__get_lcd = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt__get_lcd,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt__get_lcd,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 43,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test__lt_module_gt__show_adc
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt__show_adc[309] = {
    0x0f, 0x01, 0x00, 0x02, 0x00, 0x00, 0x1c,
    MP_QSTR_show_adc & 0xff, MP_QSTR_show_adc >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x81, 0x0b, 0x31, 0x23, 0x4e, 0x25, 0x26, 0x35, 0x2b, 0x28, 0x52, 0x2d, 0x33, 0x38, 0x26, 0x4b, 0x28, 0x2b, 0x54, 0x35, 0x33, 0x00, 0x00, 0xff,
    0xb1, 
    0x1e, MP_QSTR_read_core_temp & 0xff, MP_QSTR_read_core_temp >> 8,
    0x66, 0x00, 
    0xb1, 
    0x1e, MP_QSTR_read_core_vbat & 0xff, MP_QSTR_read_core_vbat >> 8,
    0x66, 0x00, 
    0x17, 0x02, 
    0x51, 0x03, 
    0xc2, 
    0x3f, 0x0d, 0x00, 
    0xb1, 
    0x1e, MP_QSTR_read_vref & 0xff, MP_QSTR_read_vref >> 8,
    0x66, 0x00, 
    0xb2, 
    0x82, 
    0x27, 
    0x44, 
    0x35, 0x06, 0x80, 
    0x32, 
    0x45, 
    0x35, 0x01, 0x80, 
    0x41, 
    0x80, 
    0x35, 0xde, 0x80, 
    0x30, 
    0xc3, 
    0xb0, 
    0x1e, MP_QSTR_set_text_color & 0xff, MP_QSTR_set_text_color >> 8,
    0x14, 0x86, 0x39, 
    0x14, 0x8c, 0x59, 
    0x14, 0x8c, 0x40, 
    0x50, 0x03, 
    0xb3, 
    0x21, 
    0x80, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x14, 0x81, 0x20, 
    0xd9, 
    0x37, 0x1a, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    0x82, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    0x80, 
    0x14, 0x80, 0x64, 
    0xb3, 
    0x90, 
    0xf3, 
    0xf1, 
    0x66, 0x02, 
    0x32, 
    0x35, 0x20, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    0x82, 
    0x16, MP_QSTR_trans & 0xff, MP_QSTR_trans >> 8,
    0x81, 
    0x66, 0x82, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    0x80, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x14, 0x3c, 
    0xf2, 
    0xb3, 
    0x90, 
    0xf3, 
    0xf1, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0x16, MP_QSTR__percent_4s_colon__space_ & 0xff, MP_QSTR__percent_4s_colon__space_ >> 8,
    0x16, MP_QSTR_TEMP & 0xff, MP_QSTR_TEMP >> 8,
    0x16, MP_QSTR_VBAT & 0xff, MP_QSTR_VBAT >> 8,
    0x16, MP_QSTR_VREF & 0xff, MP_QSTR_VREF >> 8,
    0x50, 0x03, 
    0xb3, 
    0x21, 
    0xf6, 
    0x66, 0x01, 
    0x32, 
    0xb3, 
    0x80, 
    0xd8, 
    0x37, 0x0b, 0x80, 
    0x16, MP_QSTR__percent_6_dot_3fV & 0xff, MP_QSTR__percent_6_dot_3fV >> 8,
    0xb2, 
    0xb3, 
    0x21, 
    0xf6, 
    0xc4, 
    0x35, 0x08, 0x80, 
    0x16, MP_QSTR__percent_5_dot_1f_Acirc__deg_C & 0xff, MP_QSTR__percent_5_dot_1f_Acirc__deg_C >> 8,
    0xb2, 
    0xb3, 
    0x21, 
    0xf6, 
    0xc4, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x14, 0x81, 0x20, 
    0xd9, 
    0x37, 0x14, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    0x81, 
    0x16, MP_QSTR_bold & 0xff, MP_QSTR_bold >> 8,
    0x80, 
    0x16, MP_QSTR_scale & 0xff, MP_QSTR_scale >> 8,
    0x81, 
    0x66, 0x84, 0x01, 
    0x32, 
    0x35, 0x28, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    0x81, 
    0x16, MP_QSTR_bold & 0xff, MP_QSTR_bold >> 8,
    0x80, 
    0x16, MP_QSTR_scale & 0xff, MP_QSTR_scale >> 8,
    0x81, 
    0x16, MP_QSTR_trans & 0xff, MP_QSTR_trans >> 8,
    0x81, 
    0x66, 0x86, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    0xad, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0x14, 0x3c, 
    0xf2, 
    0xb3, 
    0x90, 
    0xf3, 
    0xf1, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0xb4, 
    0x66, 0x01, 
    0x32, 
    0x81, 
    0xe5, 
    0x30, 
    0x83, 
    0xd7, 
    0x36, 0x1c, 0x7f, 
    0x32, 
    0x11, 
    0x5b, 
};
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__show_adc_0 = {{&mp_type_float}, 3.3};
#endif
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt__show_adc[3] = {
    MP_ROM_QSTR(MP_QSTR_lcd),
    MP_ROM_QSTR(MP_QSTR_adc),
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__show_adc_0),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xc0d33332),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
};
STATIC const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt__show_adc = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt__show_adc,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt__show_adc,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 309,
        .n_obj = 1,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test__lt_module_gt__test_features
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt__test_features[915] = {
    0x26, 0x01, 0x00, 0x02, 0x00, 0x01, 0x4a,
    MP_QSTR_test_features & 0xff, MP_QSTR_test_features >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x81, 0x26, 0x23, 0x26, 0x2c, 0x4c, 0x22, 0x67, 0x27, 0x28, 0x29, 0x67, 0x39, 0x28, 0x30, 0x2b, 0x2b, 0x2b, 0x6b, 0x22, 0x22, 0x24, 0x24, 0x3b, 0x6b, 0x24, 0x49, 0x46, 0x2d, 0x24, 0x26, 0x26, 0x3c, 0x4a, 0x26, 0x66, 0x1f, 0x2d, 0x2a, 0x37, 0x37, 0x32, 0x39, 0x39, 0x3e, 0x2e, 0x3f, 0x3e, 0x2f, 0x27, 0x27, 0x3f, 0x1f, 0x24, 0x68, 0x24, 0x68, 0x24, 0x29, 0x28, 0x27, 0x1f, 0x67, 0x2a, 0x2d, 0x63, 0x29, 0x00, 0x00, 0xff,
    0x3f, 0x1d, 0x00, 
    0x80, 
    0x11, 
    0x68, MP_QSTR_pyb & 0xff, MP_QSTR_pyb >> 8,
    0xc2, 
    0xb2, 
    0x1e, MP_QSTR_ADCAll & 0xff, MP_QSTR_ADCAll >> 8,
    0x8c, 
    0x14, 0xbc, 0x80, 0x00, 
    0x66, 0x02, 
    0xc3, 
    0xb2, 
    0x1e, MP_QSTR_RTC & 0xff, MP_QSTR_RTC >> 8,
    0x66, 0x00, 
    0xc4, 
    0x44, 
    0x35, 0x0a, 0x80, 
    0x32, 
    0x11, 
    0xc3, 
    0x11, 
    0xc4, 
    0x45, 
    0x35, 0x01, 0x80, 
    0x41, 
    0x1c, MP_QSTR_get_lcd & 0xff, MP_QSTR_get_lcd >> 8,
    0xb0, 
    0x64, 0x01, 
    0xc0, 
    0xb0, 
    0x1e, MP_QSTR_set_orient & 0xff, MP_QSTR_set_orient >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_set_pen & 0xff, MP_QSTR_set_pen >> 8,
    0x80, 
    0x80, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_erase & 0xff, MP_QSTR_erase >> 8,
    0x66, 0x00, 
    0x32, 
    0x1c, MP_QSTR_framebuf & 0xff, MP_QSTR_framebuf >> 8,
    0x1e, MP_QSTR_FrameBuffer & 0xff, MP_QSTR_FrameBuffer >> 8,
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0x14, 0x84, 0x42, 
    0x64, 0x01, 
    0x91, 
    0x91, 
    0x1c, MP_QSTR_framebuf & 0xff, MP_QSTR_framebuf >> 8,
    0x1d, MP_QSTR_RGB565 & 0xff, MP_QSTR_RGB565 >> 8,
    0x66, 0x04, 
    0xc5, 
    0xb5, 
    0x1e, MP_QSTR_fill & 0xff, MP_QSTR_fill >> 8,
    0x80, 
    0x66, 0x01, 
    0x32, 
    0xb5, 
    0x1e, MP_QSTR_fill_rect & 0xff, MP_QSTR_fill_rect >> 8,
    0x81, 
    0x81, 
    0x8f, 
    0x8f, 
    0x14, 0x87, 0xff, 0xff, 0x7f, 
    0x66, 0x05, 
    0x32, 
    0xb5, 
    0x1e, MP_QSTR_vline & 0xff, MP_QSTR_vline >> 8,
    0x84, 
    0x84, 
    0x8c, 
    0x80, 
    0x66, 0x04, 
    0x32, 
    0xb5, 
    0x1e, MP_QSTR_vline & 0xff, MP_QSTR_vline >> 8,
    0x88, 
    0x81, 
    0x8c, 
    0x80, 
    0x66, 0x04, 
    0x32, 
    0xb5, 
    0x1e, MP_QSTR_vline & 0xff, MP_QSTR_vline >> 8,
    0x8c, 
    0x84, 
    0x8c, 
    0x80, 
    0x66, 0x04, 
    0x32, 
    0xb5, 
    0x1e, MP_QSTR_vline & 0xff, MP_QSTR_vline >> 8,
    0x8e, 
    0x8d, 
    0x82, 
    0x80, 
    0x66, 0x04, 
    0x32, 
    0x8e, 
    0xc6, 
    0x93, 
    0xc7, 
    0x14, 0x80, 0x64, 
    0xc8, 
    0x14, 0x80, 0x4b, 
    0xc9, 
    0x1c, MP_QSTR_framebuf & 0xff, MP_QSTR_framebuf >> 8,
    0x1e, MP_QSTR_FrameBuffer & 0xff, MP_QSTR_FrameBuffer >> 8,
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0xb8, 
    0xb9, 
    0xf3, 
    0x82, 
    0xf3, 
    0x64, 0x01, 
    0xb8, 
    0xb9, 
    0x1c, MP_QSTR_framebuf & 0xff, MP_QSTR_framebuf >> 8,
    0x1d, MP_QSTR_RGB565 & 0xff, MP_QSTR_RGB565 >> 8,
    0x66, 0x04, 
    0xca, 
    0xb0, 
    0x1e, MP_QSTR_set_spi_win & 0xff, MP_QSTR_set_spi_win >> 8,
    0xb6, 
    0xb7, 
    0xb8, 
    0xb9, 
    0x66, 0x04, 
    0x32, 
    0x80, 
    0x30, 
    0xcb, 
    0xcc, 
    0x1c, MP_QSTR_time & 0xff, MP_QSTR_time >> 8,
    0x1e, MP_QSTR_ticks_us & 0xff, MP_QSTR_ticks_us >> 8,
    0x66, 0x00, 
    0xcd, 
    0x80, 
    0x35, 0x4e, 0x82, 
    0x30, 
    0xce, 
    0xb0, 
    0x1e, MP_QSTR_get_touch & 0xff, MP_QSTR_get_touch >> 8,
    0x66, 0x00, 
    0x59, 0x03, 
    0xcf, 
    0x22, 0x10, 
    0x22, 0x11, 
    0xbf, 
    0x37, 0x32, 0x80, 
    0x19, 0x10, 
    0xb6, 
    0xe6, 
    0x22, 0x10, 
    0x19, 0x11, 
    0xb7, 
    0xe6, 
    0x22, 0x11, 
    0x19, 0x10, 
    0x80, 
    0xdb, 
    0x37, 0x1c, 0x80, 
    0x19, 0x11, 
    0x80, 
    0xdb, 
    0x37, 0x15, 0x80, 
    0x19, 0x10, 
    0xb8, 
    0xd7, 
    0x37, 0x0e, 0x80, 
    0x19, 0x11, 
    0xb9, 
    0xd7, 
    0x37, 0x07, 0x80, 
    0x19, 0x10, 
    0x19, 0x11, 
    0x33, 
    0xcb, 
    0xcc, 
    0x35, 0x0c, 0x80, 
    0xbb, 
    0x81, 
    0xf1, 
    0xb8, 
    0xf6, 
    0xcb, 
    0xbc, 
    0x81, 
    0xf1, 
    0xb9, 
    0xf6, 
    0xcc, 
    0xba, 
    0x1e, MP_QSTR_fill & 0xff, MP_QSTR_fill >> 8,
    0xb0, 
    0x1e, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x14, 0x81, 0x00, 
    0x1c, MP_QSTR_int & 0xff, MP_QSTR_int >> 8,
    0x14, 0x80, 0x40, 
    0x1c, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x1e, MP_QSTR_cos & 0xff, MP_QSTR_cos >> 8,
    0x17, 0x02, 
    0xbe, 
    0xf3, 
    0x66, 0x01, 
    0xf3, 
    0x64, 0x01, 
    0xf1, 
    0x14, 0x81, 0x00, 
    0x14, 0x81, 0x40, 
    0x66, 0x03, 
    0x66, 0x01, 
    0x32, 
    0xba, 
    0x1e, MP_QSTR_line & 0xff, MP_QSTR_line >> 8,
    0xb8, 
    0x82, 
    0xf4, 
    0xb9, 
    0x82, 
    0xf4, 
    0xb8, 
    0x82, 
    0xf4, 
    0x1c, MP_QSTR_int & 0xff, MP_QSTR_int >> 8,
    0xa8, 
    0x1c, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x1e, MP_QSTR_cos & 0xff, MP_QSTR_cos >> 8,
    0x17, 0x03, 
    0xbe, 
    0xf3, 
    0x66, 0x01, 
    0xf3, 
    0x64, 0x01, 
    0xf1, 
    0xb9, 
    0x82, 
    0xf4, 
    0x1c, MP_QSTR_int & 0xff, MP_QSTR_int >> 8,
    0xa8, 
    0x1c, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x1e, MP_QSTR_sin & 0xff, MP_QSTR_sin >> 8,
    0x17, 0x04, 
    0xbe, 
    0xf3, 
    0x66, 0x01, 
    0xf3, 
    0x64, 0x01, 
    0xf1, 
    0xb0, 
    0x1e, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x14, 0x81, 0x00, 
    0x14, 0x81, 0x7f, 
    0x14, 0x80, 0x40, 
    0x66, 0x03, 
    0x66, 0x05, 
    0x32, 
    0xba, 
    0x1e, MP_QSTR_hline & 0xff, MP_QSTR_hline >> 8,
    0x80, 
    0xbc, 
    0xb8, 
    0xb0, 
    0x1e, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x14, 0x80, 0x40, 
    0x14, 0x80, 0x40, 
    0x14, 0x80, 0x40, 
    0x66, 0x03, 
    0x66, 0x04, 
    0x32, 
    0xba, 
    0x1e, MP_QSTR_vline & 0xff, MP_QSTR_vline >> 8,
    0xbb, 
    0x80, 
    0xb9, 
    0xb0, 
    0x1e, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x14, 0x80, 0x40, 
    0x14, 0x80, 0x40, 
    0x14, 0x80, 0x40, 
    0x66, 0x03, 
    0x66, 0x04, 
    0x32, 
    0xba, 
    0x1e, MP_QSTR_rect & 0xff, MP_QSTR_rect >> 8,
    0xbb, 
    0x83, 
    0xf2, 
    0xbc, 
    0x83, 
    0xf2, 
    0x87, 
    0x87, 
    0xb0, 
    0x1e, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x14, 0x80, 0x40, 
    0x14, 0x80, 0x40, 
    0x14, 0x80, 0x40, 
    0x66, 0x03, 
    0x66, 0x05, 
    0x32, 
    0x17, 0x05, 
    0xd1, 
    0x80, 
    0x17, 0x06, 
    0x50, 0x03, 
    0x47, 
    0x43, 0x4e, 0x00, 
    0x22, 0x12, 
    0xb8, 
    0x82, 
    0xf4, 
    0x88, 
    0xf2, 
    0x1c, MP_QSTR_int & 0xff, MP_QSTR_int >> 8,
    0x14, 0x32, 
    0x1c, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x1e, MP_QSTR_cos & 0xff, MP_QSTR_cos >> 8,
    0x17, 0x07, 
    0xbe, 
    0xf3, 
    0x19, 0x12, 
    0xf1, 
    0x66, 0x01, 
    0xf3, 
    0x64, 0x01, 
    0xf1, 
    0x22, 0x13, 
    0xb9, 
    0x82, 
    0xf4, 
    0x88, 
    0xf2, 
    0x1c, MP_QSTR_int & 0xff, MP_QSTR_int >> 8,
    0xa0, 
    0x1c, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x1e, MP_QSTR_sin & 0xff, MP_QSTR_sin >> 8,
    0x17, 0x08, 
    0xbe, 
    0xf3, 
    0x19, 0x12, 
    0xf1, 
    0x66, 0x01, 
    0xf3, 
    0x64, 0x01, 
    0xf1, 
    0x22, 0x14, 
    0xba, 
    0x1e, MP_QSTR_blit & 0xff, MP_QSTR_blit >> 8,
    0xb5, 
    0x19, 0x13, 
    0x19, 0x14, 
    0x66, 0x03, 
    0x32, 
    0x35, 0xaf, 0x7f, 
    0x7d, 
    0x35, 0x45, 0x80, 
    0x30, 
    0x22, 0x15, 
    0xba, 
    0x1e, MP_QSTR_text & 0xff, MP_QSTR_text >> 8,
    0x17, 0x09, 
    0x85, 
    0xb9, 
    0x82, 
    0xf4, 
    0x89, 
    0x19, 0x15, 
    0xf3, 
    0xf1, 
    0x1c, MP_QSTR_int & 0xff, MP_QSTR_int >> 8,
    0x94, 
    0x1c, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x1e, MP_QSTR_sin & 0xff, MP_QSTR_sin >> 8,
    0x17, 0x0a, 
    0xbe, 
    0x19, 0x15, 
    0xf1, 
    0xf3, 
    0x66, 0x01, 
    0xf3, 
    0x64, 0x01, 
    0xf1, 
    0xb0, 
    0x1e, MP_QSTR_rgb & 0xff, MP_QSTR_rgb >> 8,
    0x14, 0x81, 0x00, 
    0x8a, 
    0x19, 0x15, 
    0xf3, 
    0xf1, 
    0x80, 
    0x14, 0x81, 0x00, 
    0x8a, 
    0x19, 0x15, 
    0xf3, 
    0xf2, 
    0x66, 0x03, 
    0x66, 0x04, 
    0x32, 
    0x81, 
    0xe5, 
    0x30, 
    0x83, 
    0xd7, 
    0x36, 0xb5, 0x7f, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_show_framebuf & 0xff, MP_QSTR_show_framebuf >> 8,
    0xba, 
    0x66, 0x01, 
    0x32, 
    0xb3, 
    0x37, 0x08, 0x80, 
    0x1c, MP_QSTR_show_adc & 0xff, MP_QSTR_show_adc >> 8,
    0xb0, 
    0xb3, 
    0x64, 0x02, 
    0x32, 
    0xb4, 
    0x37, 0x3e, 0x80, 
    0xb0, 
    0x1e, MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    0x82, 
    0x80, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_set_font & 0xff, MP_QSTR_set_font >> 8,
    0x81, 
    0x66, 0x01, 
    0x32, 
    0xb4, 
    0x1e, MP_QSTR_datetime & 0xff, MP_QSTR_datetime >> 8,
    0x66, 0x00, 
    0xcf, 
    0xb0, 
    0x1e, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0x17, 0x0b, 
    0xbf, 
    0x80, 
    0x21, 
    0xbf, 
    0x81, 
    0x21, 
    0xbf, 
    0x82, 
    0x21, 
    0xbf, 
    0x84, 
    0x21, 
    0xbf, 
    0x85, 
    0x21, 
    0xbf, 
    0x86, 
    0x21, 
    0xbf, 
    0x87, 
    0x21, 
    0x14, 0x86, 0x8d, 0x20, 
    0xf4, 
    0x50, 0x07, 
    0xf6, 
    0x66, 0x01, 
    0x32, 
    0x1c, MP_QSTR_time & 0xff, MP_QSTR_time >> 8,
    0x1e, MP_QSTR_ticks_us & 0xff, MP_QSTR_ticks_us >> 8,
    0x66, 0x00, 
    0x22, 0x16, 
    0x1c, MP_QSTR_time & 0xff, MP_QSTR_time >> 8,
    0x1e, MP_QSTR_ticks_diff & 0xff, MP_QSTR_ticks_diff >> 8,
    0x19, 0x16, 
    0xbd, 
    0x66, 0x02, 
    0x22, 0x17, 
    0x19, 0x16, 
    0xcd, 
    0xb0, 
    0x1e, MP_QSTR_set_pos & 0xff, MP_QSTR_set_pos >> 8,
    0x82, 
    0x89, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0x16, MP_QSTR__percent__dot_2f_space_fps & 0xff, MP_QSTR__percent__dot_2f_space_fps >> 8,
    0x14, 0xbd, 0x84, 0x40, 
    0x19, 0x17, 
    0xf5, 
    0xf6, 
    0x66, 0x01, 
    0x32, 
    0x81, 
    0xe5, 
    0x30, 
    0x14, 0x82, 0x2c, 
    0xd7, 
    0x36, 0xaa, 0x7d, 
    0x32, 
    0x11, 
    0x5b, 
};
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_0 = {{&mp_type_float}, 0.1};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_1 = {{&mp_type_float}, 0.2};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_2 = {{&mp_type_float}, 0.2};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_3 = {{&mp_type_float}, 0.2};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_4 = {{&mp_type_float}, 0.2};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_5 = {{&mp_type_float}, 0.05};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_6 = {{&mp_type_float}, 0.05};
#endif
STATIC const mp_obj_str_t const_obj_lcd160cr_test__lt_module_gt__test_features_7 = {{&mp_type_str}, 8203, 11, (const byte*)"\x4d\x69\x63\x72\x6f\x50\x79\x74\x68\x6f\x6e"};
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_features_8 = {{&mp_type_float}, 0.1};
#endif
STATIC const mp_obj_str_t const_obj_lcd160cr_test__lt_module_gt__test_features_9 = {{&mp_type_str}, 8109, 32, (const byte*)"\x25\x34\x64\x2d\x25\x30\x32\x64\x2d\x25\x30\x32\x64\x20\x25\x32\x64\x3a\x25\x30\x32\x64\x3a\x25\x30\x32\x64\x2e\x25\x30\x31\x64"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt__test_features[12] = {
    MP_ROM_QSTR(MP_QSTR_lcd),
    MP_ROM_QSTR(MP_QSTR_orient),
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_0),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbe4cccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_1),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbeccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_2),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbeccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_3),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbeccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_4),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbeccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_5),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbdccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_6),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbdccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_7),
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_8),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xbe4cccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_features_9),
};
STATIC const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt__test_features = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt__test_features,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt__test_features,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 915,
        .n_obj = 10,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test__lt_module_gt__test_mandel_in_set
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt__test_mandel_in_set[61] = {
    0x06, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0e,
    MP_QSTR_in_set & 0xff, MP_QSTR_in_set >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x81, 0x85, 0x22, 0x26, 0x26, 0x2d, 0x2b, 0x00, 0x00, 0xff,
    0x80, 
    0xc1, 
    0x80, 
    0x35, 0x19, 0x80, 
    0x30, 
    0xc2, 
    0xb1, 
    0xb1, 
    0xf3, 
    0xb0, 
    0xf1, 
    0xc1, 
    0x1c, MP_QSTR_abs & 0xff, MP_QSTR_abs >> 8,
    0xb1, 
    0x64, 0x01, 
    0x14, 0x80, 0x64, 
    0xd8, 
    0x37, 0x02, 0x80, 
    0xb2, 
    0x5b, 
    0x81, 
    0xe5, 
    0x30, 
    0xa0, 
    0xd7, 
    0x36, 0xe1, 0x7f, 
    0x32, 
    0x80, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt__test_mandel_in_set[1] = {
    MP_ROM_QSTR(MP_QSTR_c),
};
STATIC const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt__test_mandel_in_set = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 1,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt__test_mandel_in_set,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt__test_mandel_in_set,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 61,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test__lt_module_gt__test_mandel
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt__test_mandel[231] = {
    0x15, 0x00, 0x00, 0x02, 0x00, 0x01, 0x1e,
    MP_QSTR_test_mandel & 0xff, MP_QSTR_test_mandel >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x81, 0x7e, 0x27, 0x28, 0x2c, 0x67, 0x83, 0x09, 0x25, 0x65, 0x29, 0x2b, 0x67, 0x27, 0x27, 0x27, 0x27, 0x34, 0x26, 0x4b, 0x29, 0x26, 0x34, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_get_lcd & 0xff, MP_QSTR_get_lcd >> 8,
    0xb0, 
    0x64, 0x01, 
    0xc0, 
    0xb0, 
    0x1e, MP_QSTR_set_orient & 0xff, MP_QSTR_set_orient >> 8,
    0xb1, 
    0x66, 0x01, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_set_pen & 0xff, MP_QSTR_set_pen >> 8,
    0x80, 
    0x14, 0x83, 0xff, 0x7f, 
    0x66, 0x02, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_erase & 0xff, MP_QSTR_erase >> 8,
    0x66, 0x00, 
    0x32, 
    0x60, 0x07, 
    0xc2, 
    0xb0, 
    0x1d, MP_QSTR_w & 0xff, MP_QSTR_w >> 8,
    0xc3, 
    0xb0, 
    0x1d, MP_QSTR_h & 0xff, MP_QSTR_h >> 8,
    0xc4, 
    0x1c, MP_QSTR_bytearray & 0xff, MP_QSTR_bytearray >> 8,
    0xb3, 
    0x82, 
    0xf3, 
    0x64, 0x01, 
    0xc5, 
    0xb0, 
    0x1e, MP_QSTR_set_spi_win & 0xff, MP_QSTR_set_spi_win >> 8,
    0x80, 
    0x80, 
    0xb3, 
    0xb4, 
    0x66, 0x04, 
    0x32, 
    0xb0, 
    0x1e, MP_QSTR_fast_spi & 0xff, MP_QSTR_fast_spi >> 8,
    0x66, 0x00, 
    0xc6, 
    0xb4, 
    0x81, 
    0xf2, 
    0x17, 0x02, 
    0xf5, 
    0xc7, 
    0xb3, 
    0x81, 
    0xf2, 
    0x17, 0x03, 
    0xf5, 
    0xc8, 
    0xb4, 
    0x80, 
    0x35, 0x5b, 0x80, 
    0x30, 
    0xc9, 
    0xb3, 
    0x80, 
    0x35, 0x42, 0x80, 
    0x30, 
    0xca, 
    0xb2, 
    0xb9, 
    0xb7, 
    0xf5, 
    0x17, 0x04, 
    0xf2, 
    0xba, 
    0xb8, 
    0xf5, 
    0x17, 0x05, 
    0xf2, 
    0x17, 0x06, 
    0xf3, 
    0xf1, 
    0x64, 0x01, 
    0xcb, 
    0xbb, 
    0x90, 
    0xd7, 
    0x37, 0x0b, 0x80, 
    0xbb, 
    0x8c, 
    0xef, 
    0xbb, 
    0x86, 
    0xef, 
    0xec, 
    0xcc, 
    0x35, 0x09, 0x80, 
    0x14, 0x83, 0xf0, 0x00, 
    0xbb, 
    0x86, 
    0xef, 
    0xec, 
    0xcc, 
    0xbc, 
    0xb5, 
    0x82, 
    0xba, 
    0xf3, 
    0x27, 
    0xbc, 
    0x88, 
    0xf0, 
    0xb5, 
    0x82, 
    0xba, 
    0xf3, 
    0x81, 
    0xf1, 
    0x27, 
    0x81, 
    0xe5, 
    0x31, 
    0x33, 
    0xd7, 
    0x36, 0xb8, 0x7f, 
    0x32, 
    0x32, 
    0xb6, 
    0x1e, MP_QSTR_write & 0xff, MP_QSTR_write >> 8,
    0xb5, 
    0x66, 0x01, 
    0x32, 
    0x81, 
    0xe5, 
    0x31, 
    0x33, 
    0xd7, 
    0x36, 0x9f, 0x7f, 
    0x32, 
    0x32, 
    0x11, 
    0x5b, 
};
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_mandel_0 = {{&mp_type_float}, 3.2};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_mandel_1 = {{&mp_type_float}, 2.4};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_mandel_2 = {{&mp_type_float}, 2.3};
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
STATIC const mp_obj_float_t const_obj_lcd160cr_test__lt_module_gt__test_mandel_3 = {{&mp_type_float}, 1.2};
#endif
STATIC const mp_obj_complex_t const_obj_lcd160cr_test__lt_module_gt__test_mandel_4 = {{&mp_type_complex}, 0, 1};
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt__test_mandel[8] = {
    MP_ROM_QSTR(MP_QSTR_lcd),
    MP_ROM_QSTR(MP_QSTR_orient),
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_mandel_0),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xc0ccccce),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_mandel_1),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xc099999a),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_mandel_2),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xc0933332),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_mandel_3),
#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
    (mp_rom_obj_t)(0xc019999a),
#else
#error "MICROPY_OBJ_REPR_D not supported with floats in frozen mpy files"
#endif
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__test_mandel_4),
    MP_ROM_PTR(&raw_code_lcd160cr_test__lt_module_gt__test_mandel_in_set),
};
STATIC const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt__test_mandel = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt__test_mandel,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt__test_mandel,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 231,
        .n_obj = 5,
        .n_raw_code = 1,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test__lt_module_gt__test_all
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt__test_all[43] = {
    0x05, 0x00, 0x00, 0x02, 0x00, 0x01, 0x0b,
    MP_QSTR_test_all & 0xff, MP_QSTR_test_all >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x81, 0xa4, 0x27, 0x28, 0x00, 0x00, 0xff,
    0x1c, MP_QSTR_get_lcd & 0xff, MP_QSTR_get_lcd >> 8,
    0xb0, 
    0x64, 0x01, 
    0xc0, 
    0x1c, MP_QSTR_test_features & 0xff, MP_QSTR_test_features >> 8,
    0xb0, 
    0xb1, 
    0x64, 0x02, 
    0x32, 
    0x1c, MP_QSTR_test_mandel & 0xff, MP_QSTR_test_mandel >> 8,
    0xb0, 
    0xb1, 
    0x64, 0x02, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt__test_all[2] = {
    MP_ROM_QSTR(MP_QSTR_lcd),
    MP_ROM_QSTR(MP_QSTR_orient),
};
STATIC const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt__test_all = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 2,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt__test_all,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt__test_all,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 43,
        .n_obj = 0,
        .n_raw_code = 0,
        #endif
    },
};

// frozen bytecode for file lcd160cr_test.py, scope lcd160cr_test_<module>
STATIC const byte bytecode_data_lcd160cr_test__lt_module_gt_[139] = {
    0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
    MP_QSTR__lt_module_gt_ & 0xff, MP_QSTR__lt_module_gt_ >> 8,
    MP_QSTR_lcd160cr_test_dot_py & 0xff, MP_QSTR_lcd160cr_test_dot_py >> 8,
    0x61, 0x1f, 0x41, 0x65, 0x40, 0x85, 0x1a, 0x8e, 0x58, 0x8e, 0x27, 0x6e, 0x40, 0x28, 0x28, 0x00, 0x00, 0xff,
    0x80, 
    0x11, 
    0x68, MP_QSTR_time & 0xff, MP_QSTR_time >> 8,
    0x24, MP_QSTR_time & 0xff, MP_QSTR_time >> 8,
    0x80, 
    0x11, 
    0x68, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x24, MP_QSTR_math & 0xff, MP_QSTR_math >> 8,
    0x80, 
    0x11, 
    0x68, MP_QSTR_framebuf & 0xff, MP_QSTR_framebuf >> 8,
    0x24, MP_QSTR_framebuf & 0xff, MP_QSTR_framebuf >> 8,
    0x80, 
    0x11, 
    0x68, MP_QSTR_lcd160cr & 0xff, MP_QSTR_lcd160cr >> 8,
    0x24, MP_QSTR_lcd160cr & 0xff, MP_QSTR_lcd160cr >> 8,
    0x60, 0x03, 
    0x24, MP_QSTR_get_lcd & 0xff, MP_QSTR_get_lcd >> 8,
    0x60, 0x04, 
    0x24, MP_QSTR_show_adc & 0xff, MP_QSTR_show_adc >> 8,
    0x1b, MP_QSTR_lcd160cr & 0xff, MP_QSTR_lcd160cr >> 8,
    0x1d, MP_QSTR_PORTRAIT & 0xff, MP_QSTR_PORTRAIT >> 8,
    0x50, 0x01, 
    0x18, 
    0x61, 0x05, 
    0x24, MP_QSTR_test_features & 0xff, MP_QSTR_test_features >> 8,
    0x1b, MP_QSTR_lcd160cr & 0xff, MP_QSTR_lcd160cr >> 8,
    0x1d, MP_QSTR_PORTRAIT & 0xff, MP_QSTR_PORTRAIT >> 8,
    0x50, 0x01, 
    0x18, 
    0x61, 0x06, 
    0x24, MP_QSTR_test_mandel & 0xff, MP_QSTR_test_mandel >> 8,
    0x1b, MP_QSTR_lcd160cr & 0xff, MP_QSTR_lcd160cr >> 8,
    0x1d, MP_QSTR_PORTRAIT & 0xff, MP_QSTR_PORTRAIT >> 8,
    0x50, 0x01, 
    0x18, 
    0x61, 0x07, 
    0x24, MP_QSTR_test_all & 0xff, MP_QSTR_test_all >> 8,
    0x1b, MP_QSTR_print & 0xff, MP_QSTR_print >> 8,
    0x17, 0x00, 
    0x64, 0x01, 
    0x32, 
    0x1b, MP_QSTR_print & 0xff, MP_QSTR_print >> 8,
    0x17, 0x01, 
    0x64, 0x01, 
    0x32, 
    0x1b, MP_QSTR_print & 0xff, MP_QSTR_print >> 8,
    0x17, 0x02, 
    0x64, 0x01, 
    0x32, 
    0x11, 
    0x5b, 
};
STATIC const mp_obj_str_t const_obj_lcd160cr_test__lt_module_gt__0 = {{&mp_type_str}, 8425, 33, (const byte*)"\x54\x6f\x20\x72\x75\x6e\x20\x61\x6c\x6c\x20\x74\x65\x73\x74\x73\x3a\x20\x74\x65\x73\x74\x5f\x61\x6c\x6c\x28\x3c\x6c\x63\x64\x3e\x29"};
STATIC const mp_obj_str_t const_obj_lcd160cr_test__lt_module_gt__1 = {{&mp_type_str}, 43873, 48, (const byte*)"\x49\x6e\x64\x69\x76\x69\x64\x75\x61\x6c\x20\x74\x65\x73\x74\x73\x20\x61\x72\x65\x3a\x20\x74\x65\x73\x74\x5f\x66\x65\x61\x74\x75\x72\x65\x73\x2c\x20\x74\x65\x73\x74\x5f\x6d\x61\x6e\x64\x65\x6c"};
STATIC const mp_obj_str_t const_obj_lcd160cr_test__lt_module_gt__2 = {{&mp_type_str}, 63446, 68, (const byte*)"\x3c\x6c\x63\x64\x3e\x20\x61\x72\x67\x75\x6d\x65\x6e\x74\x20\x73\x68\x6f\x75\x6c\x64\x20\x62\x65\x20\x61\x20\x63\x6f\x6e\x6e\x65\x63\x74\x69\x6f\x6e\x2c\x20\x65\x67\x20\x22\x58\x22\x2c\x20\x6f\x72\x20\x61\x6e\x20\x4c\x43\x44\x31\x36\x30\x43\x52\x20\x6f\x62\x6a\x65\x63\x74"};
STATIC const mp_rom_obj_t const_table_data_lcd160cr_test__lt_module_gt_[8] = {
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__0),
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__1),
    MP_ROM_PTR(&const_obj_lcd160cr_test__lt_module_gt__2),
    MP_ROM_PTR(&raw_code_lcd160cr_test__lt_module_gt__get_lcd),
    MP_ROM_PTR(&raw_code_lcd160cr_test__lt_module_gt__show_adc),
    MP_ROM_PTR(&raw_code_lcd160cr_test__lt_module_gt__test_features),
    MP_ROM_PTR(&raw_code_lcd160cr_test__lt_module_gt__test_mandel),
    MP_ROM_PTR(&raw_code_lcd160cr_test__lt_module_gt__test_all),
};
const mp_raw_code_t raw_code_lcd160cr_test__lt_module_gt_ = {
    .kind = MP_CODE_BYTECODE,
    .scope_flags = 0x00,
    .n_pos_args = 0,
    .data.u_byte = {
        .bytecode = bytecode_data_lcd160cr_test__lt_module_gt_,
        .const_table = (mp_uint_t*)const_table_data_lcd160cr_test__lt_module_gt_,
        #if MICROPY_PERSISTENT_CODE_SAVE
        .bc_len = 139,
        .n_obj = 3,
        .n_raw_code = 5,
        #endif
    },
};

const char mp_frozen_mpy_names[] = {
"lcd160cr.py\0"
"lcd160cr_test.py\0"
"\0"};
const mp_raw_code_t *const mp_frozen_mpy_content[] = {
    &raw_code_lcd160cr__lt_module_gt_,
    &raw_code_lcd160cr_test__lt_module_gt_,
};
